head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.13 netbsd-11-0-RC3:1.1.1.13 netbsd-11-0-RC2:1.1.1.13 netbsd-11-0-RC1:1.1.1.13 perseant-exfatfs-base-20250801:1.1.1.13 netbsd-11:1.1.1.13.0.10 netbsd-11-base:1.1.1.13 netbsd-10-1-RELEASE:1.1.1.13 perseant-exfatfs-base-20240630:1.1.1.13 perseant-exfatfs:1.1.1.13.0.8 perseant-exfatfs-base:1.1.1.13 netbsd-8-3-RELEASE:1.1.1.10 netbsd-9-4-RELEASE:1.1.1.12 netbsd-10-0-RELEASE:1.1.1.13 netbsd-10-0-RC6:1.1.1.13 netbsd-10-0-RC5:1.1.1.13 netbsd-10-0-RC4:1.1.1.13 netbsd-10-0-RC3:1.1.1.13 netbsd-10-0-RC2:1.1.1.13 netbsd-10-0-RC1:1.1.1.13 netbsd-10:1.1.1.13.0.6 netbsd-10-base:1.1.1.13 netbsd-9-3-RELEASE:1.1.1.12 cjep_sun2x:1.1.1.13.0.4 cjep_sun2x-base:1.1.1.13 cjep_staticlib_x-base1:1.1.1.13 netbsd-9-2-RELEASE:1.1.1.12 cjep_staticlib_x:1.1.1.13.0.2 cjep_staticlib_x-base:1.1.1.13 netbsd-9-1-RELEASE:1.1.1.12 phil-wifi-20200421:1.1.1.13 phil-wifi-20200411:1.1.1.13 phil-wifi-20200406:1.1.1.13 netbsd-8-2-RELEASE:1.1.1.10 netbsd-9-0-RELEASE:1.1.1.12 netbsd-9-0-RC2:1.1.1.12 netbsd-9-0-RC1:1.1.1.12 netbsd-9:1.1.1.12.0.2 netbsd-9-base:1.1.1.12 phil-wifi-20190609:1.1.1.12 netbsd-8-1-RELEASE:1.1.1.10 netbsd-8-1-RC1:1.1.1.10 pgoyette-compat-merge-20190127:1.1.1.11.2.1 pgoyette-compat-20190127:1.1.1.12 pgoyette-compat-20190118:1.1.1.12 pgoyette-compat-1226:1.1.1.12 pgoyette-compat-1126:1.1.1.12 pgoyette-compat-1020:1.1.1.12 pgoyette-compat-0930:1.1.1.12 pgoyette-compat-0906:1.1.1.12 netbsd-7-2-RELEASE:1.1.1.7.2.1 pgoyette-compat-0728:1.1.1.12 clang-337282:1.1.1.12 netbsd-8-0-RELEASE:1.1.1.10 phil-wifi:1.1.1.11.0.4 phil-wifi-base:1.1.1.11 pgoyette-compat-0625:1.1.1.11 netbsd-8-0-RC2:1.1.1.10 pgoyette-compat-0521:1.1.1.11 pgoyette-compat-0502:1.1.1.11 pgoyette-compat-0422:1.1.1.11 netbsd-8-0-RC1:1.1.1.10 pgoyette-compat-0415:1.1.1.11 pgoyette-compat-0407:1.1.1.11 pgoyette-compat-0330:1.1.1.11 pgoyette-compat-0322:1.1.1.11 pgoyette-compat-0315:1.1.1.11 netbsd-7-1-2-RELEASE:1.1.1.7.2.1 pgoyette-compat:1.1.1.11.0.2 pgoyette-compat-base:1.1.1.11 netbsd-7-1-1-RELEASE:1.1.1.7.2.1 clang-319952:1.1.1.11 matt-nb8-mediatek:1.1.1.10.0.10 matt-nb8-mediatek-base:1.1.1.10 clang-309604:1.1.1.11 perseant-stdc-iso10646:1.1.1.10.0.8 perseant-stdc-iso10646-base:1.1.1.10 netbsd-8:1.1.1.10.0.6 netbsd-8-base:1.1.1.10 prg-localcount2-base3:1.1.1.10 prg-localcount2-base2:1.1.1.10 prg-localcount2-base1:1.1.1.10 prg-localcount2:1.1.1.10.0.4 prg-localcount2-base:1.1.1.10 pgoyette-localcount-20170426:1.1.1.10 bouyer-socketcan-base1:1.1.1.10 pgoyette-localcount-20170320:1.1.1.10 netbsd-7-1:1.1.1.7.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.7.2.1 netbsd-7-1-RC2:1.1.1.7.2.1 clang-294123:1.1.1.10 netbsd-7-nhusb-base-20170116:1.1.1.7.2.1 bouyer-socketcan:1.1.1.10.0.2 bouyer-socketcan-base:1.1.1.10 clang-291444:1.1.1.10 pgoyette-localcount-20170107:1.1.1.9 netbsd-7-1-RC1:1.1.1.7.2.1 pgoyette-localcount-20161104:1.1.1.9 netbsd-7-0-2-RELEASE:1.1.1.7.2.1 localcount-20160914:1.1.1.9 netbsd-7-nhusb:1.1.1.7.2.1.0.4 netbsd-7-nhusb-base:1.1.1.7.2.1 clang-280599:1.1.1.9 pgoyette-localcount-20160806:1.1.1.9 pgoyette-localcount-20160726:1.1.1.9 pgoyette-localcount:1.1.1.9.0.2 pgoyette-localcount-base:1.1.1.9 netbsd-7-0-1-RELEASE:1.1.1.7.2.1 clang-261930:1.1.1.9 netbsd-7-0:1.1.1.7.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.7.2.1 netbsd-7-0-RC3:1.1.1.7.2.1 netbsd-7-0-RC2:1.1.1.7.2.1 netbsd-7-0-RC1:1.1.1.7.2.1 clang-237755:1.1.1.8 clang-232565:1.1.1.8 clang-227398:1.1.1.8 tls-maxphys-base:1.1.1.7 tls-maxphys:1.1.1.7.0.4 netbsd-7:1.1.1.7.0.2 netbsd-7-base:1.1.1.7 clang-215315:1.1.1.7 clang-209886:1.1.1.6 yamt-pagecache:1.1.1.5.0.4 yamt-pagecache-base9:1.1.1.5 tls-earlyentropy:1.1.1.5.0.2 tls-earlyentropy-base:1.1.1.6 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.5 riastradh-drm2-base3:1.1.1.5 clang-202566:1.1.1.5 clang-201163:1.1.1.4 clang-199312:1.1.1.3 clang-198450:1.1.1.2 clang-196603:1.1.1.1 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.49; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.49; author joerg; state Exp; branches; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2014.01.05.15.38.28; author joerg; state Exp; branches; next 1.1.1.3; commitid wh3aCSIWykURqWjx; 1.1.1.3 date 2014.01.15.21.26.19; author joerg; state Exp; branches; next 1.1.1.4; commitid NQXlzzA0SPkc5glx; 1.1.1.4 date 2014.02.14.20.07.06; author joerg; state Exp; branches; next 1.1.1.5; commitid annVkZ1sc17rF6px; 1.1.1.5 date 2014.03.04.19.53.37; author joerg; state Exp; branches 1.1.1.5.2.1 1.1.1.5.4.1; next 1.1.1.6; commitid 29z1hJonZISIXprx; 1.1.1.6 date 2014.05.30.18.14.40; author joerg; state Exp; branches; next 1.1.1.7; commitid 8q0kdlBlCn09GACx; 1.1.1.7 date 2014.08.10.17.08.26; author joerg; state Exp; branches 1.1.1.7.2.1 1.1.1.7.4.1; next 1.1.1.8; commitid N85tXAN6Ex9VZPLx; 1.1.1.8 date 2015.01.29.19.57.32; author joerg; state Exp; branches; next 1.1.1.9; commitid mlISSizlPKvepX7y; 1.1.1.9 date 2016.02.27.22.11.52; author joerg; state Exp; branches 1.1.1.9.2.1; next 1.1.1.10; commitid tIimz3oDlh1NpBWy; 1.1.1.10 date 2017.01.11.10.35.42; author joerg; state Exp; branches; next 1.1.1.11; commitid CNnUNfII1jgNmxBz; 1.1.1.11 date 2017.08.01.19.34.56; author joerg; state Exp; branches 1.1.1.11.2.1 1.1.1.11.4.1; next 1.1.1.12; commitid pMuDy65V0VicSx1A; 1.1.1.12 date 2018.07.17.18.31.04; author joerg; state Exp; branches; next 1.1.1.13; commitid wDzL46ALjrCZgwKA; 1.1.1.13 date 2019.11.13.22.19.20; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.5.2.1 date 2014.08.10.07.08.07; author tls; state Exp; branches; next ; commitid t01A1TLTYxkpGMLx; 1.1.1.5.4.1 date 2014.03.04.19.53.37; author yamt; state dead; branches; next 1.1.1.5.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.5.4.2 date 2014.05.22.16.18.26; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.7.2.1 date 2015.06.04.20.04.27; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.7.4.1 date 2014.08.10.17.08.26; author tls; state dead; branches; next 1.1.1.7.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.7.4.2 date 2014.08.19.23.47.26; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.9.2.1 date 2017.03.20.06.52.36; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.11.2.1 date 2018.07.28.04.33.16; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.11.4.1 date 2019.06.10.21.45.20; author christos; state Exp; branches; next 1.1.1.11.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.11.4.2 date 2020.04.13.07.46.30; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===--- Registry.cpp - Matcher registry -------------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===------------------------------------------------------------===// /// /// \file /// \brief Registry map populated at static initialization time. /// //===------------------------------------------------------------===// #include "clang/ASTMatchers/Dynamic/Registry.h" #include #include "Marshallers.h" #include "clang/ASTMatchers/ASTMatchers.h" #include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringRef.h" #include "llvm/Support/ManagedStatic.h" namespace clang { namespace ast_matchers { namespace dynamic { namespace { using internal::MatcherCreateCallback; typedef llvm::StringMap ConstructorMap; class RegistryMaps { public: RegistryMaps(); ~RegistryMaps(); const ConstructorMap &constructors() const { return Constructors; } private: void registerMatcher(StringRef MatcherName, MatcherCreateCallback *Callback); ConstructorMap Constructors; }; void RegistryMaps::registerMatcher(StringRef MatcherName, MatcherCreateCallback *Callback) { assert(Constructors.find(MatcherName) == Constructors.end()); Constructors[MatcherName] = Callback; } #define REGISTER_MATCHER(name) \ registerMatcher(#name, internal::makeMatcherAutoMarshall( \ ::clang::ast_matchers::name, #name)); #define SPECIFIC_MATCHER_OVERLOAD(name, Id) \ static_cast< ::clang::ast_matchers::name##_Type##Id>( \ ::clang::ast_matchers::name) #define REGISTER_OVERLOADED_2(name) \ do { \ MatcherCreateCallback *Callbacks[] = { \ internal::makeMatcherAutoMarshall(SPECIFIC_MATCHER_OVERLOAD(name, 0), \ #name), \ internal::makeMatcherAutoMarshall(SPECIFIC_MATCHER_OVERLOAD(name, 1), \ #name) \ }; \ registerMatcher(#name, \ new internal::OverloadedMatcherCreateCallback(Callbacks)); \ } while (0) /// \brief Generate a registry map with all the known matchers. RegistryMaps::RegistryMaps() { // TODO: Here is the list of the missing matchers, grouped by reason. // // Need Variant/Parser fixes: // ofKind // // Polymorphic + argument overload: // unless // findAll // // Other: // loc // equals // equalsNode REGISTER_OVERLOADED_2(callee); REGISTER_OVERLOADED_2(hasPrefix); REGISTER_OVERLOADED_2(hasType); REGISTER_OVERLOADED_2(isDerivedFrom); REGISTER_OVERLOADED_2(isSameOrDerivedFrom); REGISTER_OVERLOADED_2(pointsTo); REGISTER_OVERLOADED_2(references); REGISTER_OVERLOADED_2(thisPointerType); REGISTER_MATCHER(accessSpecDecl); REGISTER_MATCHER(alignOfExpr); REGISTER_MATCHER(allOf); REGISTER_MATCHER(anyOf); REGISTER_MATCHER(anything); REGISTER_MATCHER(argumentCountIs); REGISTER_MATCHER(arraySubscriptExpr); REGISTER_MATCHER(arrayType); REGISTER_MATCHER(asString); REGISTER_MATCHER(asmStmt); REGISTER_MATCHER(atomicType); REGISTER_MATCHER(autoType); REGISTER_MATCHER(binaryOperator); REGISTER_MATCHER(bindTemporaryExpr); REGISTER_MATCHER(blockPointerType); REGISTER_MATCHER(boolLiteral); REGISTER_MATCHER(breakStmt); REGISTER_MATCHER(builtinType); REGISTER_MATCHER(cStyleCastExpr); REGISTER_MATCHER(callExpr); REGISTER_MATCHER(castExpr); REGISTER_MATCHER(catchStmt); REGISTER_MATCHER(characterLiteral); REGISTER_MATCHER(classTemplateDecl); REGISTER_MATCHER(classTemplateSpecializationDecl); REGISTER_MATCHER(complexType); REGISTER_MATCHER(compoundLiteralExpr); REGISTER_MATCHER(compoundStmt); REGISTER_MATCHER(conditionalOperator); REGISTER_MATCHER(constCastExpr); REGISTER_MATCHER(constantArrayType); REGISTER_MATCHER(constructExpr); REGISTER_MATCHER(constructorDecl); REGISTER_MATCHER(containsDeclaration); REGISTER_MATCHER(continueStmt); REGISTER_MATCHER(ctorInitializer); REGISTER_MATCHER(decl); REGISTER_MATCHER(declCountIs); REGISTER_MATCHER(declRefExpr); REGISTER_MATCHER(declStmt); REGISTER_MATCHER(defaultArgExpr); REGISTER_MATCHER(deleteExpr); REGISTER_MATCHER(dependentSizedArrayType); REGISTER_MATCHER(destructorDecl); REGISTER_MATCHER(doStmt); REGISTER_MATCHER(dynamicCastExpr); REGISTER_MATCHER(eachOf); REGISTER_MATCHER(elaboratedType); REGISTER_MATCHER(enumConstantDecl); REGISTER_MATCHER(enumDecl); REGISTER_MATCHER(explicitCastExpr); REGISTER_MATCHER(expr); REGISTER_MATCHER(fieldDecl); REGISTER_MATCHER(floatLiteral); REGISTER_MATCHER(forEach); REGISTER_MATCHER(forEachDescendant); REGISTER_MATCHER(forField); REGISTER_MATCHER(forRangeStmt); REGISTER_MATCHER(forStmt); REGISTER_MATCHER(functionDecl); REGISTER_MATCHER(functionTemplateDecl); REGISTER_MATCHER(functionType); REGISTER_MATCHER(functionalCastExpr); REGISTER_MATCHER(gotoStmt); REGISTER_MATCHER(has); REGISTER_MATCHER(hasAncestor); REGISTER_MATCHER(hasAnyArgument); REGISTER_MATCHER(hasAnyConstructorInitializer); REGISTER_MATCHER(hasAnyParameter); REGISTER_MATCHER(hasAnySubstatement); REGISTER_MATCHER(hasAnyTemplateArgument); REGISTER_MATCHER(hasAnyUsingShadowDecl); REGISTER_MATCHER(hasArgument); REGISTER_MATCHER(hasArgumentOfType); REGISTER_MATCHER(hasBase); REGISTER_MATCHER(hasBody); REGISTER_MATCHER(hasCanonicalType); REGISTER_MATCHER(hasCondition); REGISTER_MATCHER(hasConditionVariableStatement); REGISTER_MATCHER(hasDeclContext); REGISTER_MATCHER(hasDeclaration); REGISTER_MATCHER(hasDeducedType); REGISTER_MATCHER(hasDescendant); REGISTER_MATCHER(hasDestinationType); REGISTER_MATCHER(hasEitherOperand); REGISTER_MATCHER(hasElementType); REGISTER_MATCHER(hasFalseExpression); REGISTER_MATCHER(hasImplicitDestinationType); REGISTER_MATCHER(hasIncrement); REGISTER_MATCHER(hasIndex); REGISTER_MATCHER(hasInitializer); REGISTER_MATCHER(hasLHS); REGISTER_MATCHER(hasLocalQualifiers); REGISTER_MATCHER(hasLoopInit); REGISTER_MATCHER(hasMethod); REGISTER_MATCHER(hasName); REGISTER_MATCHER(hasObjectExpression); REGISTER_MATCHER(hasOperatorName); REGISTER_MATCHER(hasOverloadedOperatorName); REGISTER_MATCHER(hasParameter); REGISTER_MATCHER(hasParent); REGISTER_MATCHER(hasQualifier); REGISTER_MATCHER(hasRHS); REGISTER_MATCHER(hasSingleDecl); REGISTER_MATCHER(hasSize); REGISTER_MATCHER(hasSizeExpr); REGISTER_MATCHER(hasSourceExpression); REGISTER_MATCHER(hasTargetDecl); REGISTER_MATCHER(hasTemplateArgument); REGISTER_MATCHER(hasTrueExpression); REGISTER_MATCHER(hasUnaryOperand); REGISTER_MATCHER(hasValueType); REGISTER_MATCHER(ifStmt); REGISTER_MATCHER(ignoringImpCasts); REGISTER_MATCHER(ignoringParenCasts); REGISTER_MATCHER(ignoringParenImpCasts); REGISTER_MATCHER(implicitCastExpr); REGISTER_MATCHER(incompleteArrayType); REGISTER_MATCHER(initListExpr); REGISTER_MATCHER(innerType); REGISTER_MATCHER(integerLiteral); REGISTER_MATCHER(isArrow); REGISTER_MATCHER(isConstQualified); REGISTER_MATCHER(isDefinition); REGISTER_MATCHER(isExplicitTemplateSpecialization); REGISTER_MATCHER(isExternC); REGISTER_MATCHER(isImplicit); REGISTER_MATCHER(isInteger); REGISTER_MATCHER(isOverride); REGISTER_MATCHER(isPrivate); REGISTER_MATCHER(isProtected); REGISTER_MATCHER(isPublic); REGISTER_MATCHER(isTemplateInstantiation); REGISTER_MATCHER(isVirtual); REGISTER_MATCHER(isWritten); REGISTER_MATCHER(lValueReferenceType); REGISTER_MATCHER(labelStmt); REGISTER_MATCHER(lambdaExpr); REGISTER_MATCHER(matchesName); REGISTER_MATCHER(materializeTemporaryExpr); REGISTER_MATCHER(member); REGISTER_MATCHER(memberCallExpr); REGISTER_MATCHER(memberExpr); REGISTER_MATCHER(memberPointerType); REGISTER_MATCHER(methodDecl); REGISTER_MATCHER(namedDecl); REGISTER_MATCHER(namesType); REGISTER_MATCHER(namespaceDecl); REGISTER_MATCHER(nestedNameSpecifier); REGISTER_MATCHER(nestedNameSpecifierLoc); REGISTER_MATCHER(newExpr); REGISTER_MATCHER(nullPtrLiteralExpr); REGISTER_MATCHER(nullStmt); REGISTER_MATCHER(ofClass); REGISTER_MATCHER(on); REGISTER_MATCHER(onImplicitObjectArgument); REGISTER_MATCHER(operatorCallExpr); REGISTER_MATCHER(parameterCountIs); REGISTER_MATCHER(parenType); REGISTER_MATCHER(pointee); REGISTER_MATCHER(pointerType); REGISTER_MATCHER(qualType); REGISTER_MATCHER(rValueReferenceType); REGISTER_MATCHER(recordDecl); REGISTER_MATCHER(recordType); REGISTER_MATCHER(referenceType); REGISTER_MATCHER(refersToDeclaration); REGISTER_MATCHER(refersToType); REGISTER_MATCHER(reinterpretCastExpr); REGISTER_MATCHER(returnStmt); REGISTER_MATCHER(returns); REGISTER_MATCHER(sizeOfExpr); REGISTER_MATCHER(specifiesNamespace); REGISTER_MATCHER(specifiesType); REGISTER_MATCHER(specifiesTypeLoc); REGISTER_MATCHER(statementCountIs); REGISTER_MATCHER(staticCastExpr); REGISTER_MATCHER(stmt); REGISTER_MATCHER(stringLiteral); REGISTER_MATCHER(switchCase); REGISTER_MATCHER(switchStmt); REGISTER_MATCHER(templateSpecializationType); REGISTER_MATCHER(thisExpr); REGISTER_MATCHER(throughUsingDecl); REGISTER_MATCHER(throwExpr); REGISTER_MATCHER(to); REGISTER_MATCHER(tryStmt); REGISTER_MATCHER(type); REGISTER_MATCHER(typeLoc); REGISTER_MATCHER(typedefType); REGISTER_MATCHER(unaryExprOrTypeTraitExpr); REGISTER_MATCHER(unaryOperator); REGISTER_MATCHER(userDefinedLiteral); REGISTER_MATCHER(usingDecl); REGISTER_MATCHER(varDecl); REGISTER_MATCHER(variableArrayType); REGISTER_MATCHER(whileStmt); REGISTER_MATCHER(withInitializer); } RegistryMaps::~RegistryMaps() { for (ConstructorMap::iterator it = Constructors.begin(), end = Constructors.end(); it != end; ++it) { delete it->second; } } static llvm::ManagedStatic RegistryData; } // anonymous namespace // static VariantMatcher Registry::constructMatcher(StringRef MatcherName, const SourceRange &NameRange, ArrayRef Args, Diagnostics *Error) { ConstructorMap::const_iterator it = RegistryData->constructors().find(MatcherName); if (it == RegistryData->constructors().end()) { Error->addError(NameRange, Error->ET_RegistryNotFound) << MatcherName; return VariantMatcher(); } return it->second->run(NameRange, Args, Error); } // static VariantMatcher Registry::constructBoundMatcher(StringRef MatcherName, const SourceRange &NameRange, StringRef BindID, ArrayRef Args, Diagnostics *Error) { VariantMatcher Out = constructMatcher(MatcherName, NameRange, Args, Error); if (Out.isNull()) return Out; llvm::Optional Result = Out.getSingleMatcher(); if (Result.hasValue()) { llvm::Optional Bound = Result->tryBind(BindID); if (Bound.hasValue()) { return VariantMatcher::SingleMatcher(*Bound); } } Error->addError(NameRange, Error->ET_RegistryNotBindable); return VariantMatcher(); } } // namespace dynamic } // namespace ast_matchers } // namespace clang @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.2 log @Import clang 3.5svn r198450. @ text @d30 1 a30 1 using internal::MatcherDescriptor; d32 1 a32 1 typedef llvm::StringMap ConstructorMap; d41 1 a41 1 void registerMatcher(StringRef MatcherName, MatcherDescriptor *Callback); d46 1 a46 1 MatcherDescriptor *Callback) { d61 1 a61 1 MatcherDescriptor *Callbacks[] = { \ d68 1 a68 1 new internal::OverloadedMatcherDescriptor(Callbacks)); \ d79 1 a115 1 REGISTER_MATCHER(caseStmt); a135 1 REGISTER_MATCHER(declaratorDecl); a136 1 REGISTER_MATCHER(defaultStmt); a145 1 REGISTER_MATCHER(equalsBoundNode); a150 1 REGISTER_MATCHER(forEachConstructorInitializer); a151 1 REGISTER_MATCHER(forEachSwitchCase); a154 1 REGISTER_MATCHER(friendDecl); a172 1 REGISTER_MATCHER(hasCaseConstant); a205 1 REGISTER_MATCHER(hasTypeLoc); a217 1 REGISTER_MATCHER(isConst); a254 1 REGISTER_MATCHER(parmVarDecl); a277 1 REGISTER_MATCHER(temporaryObjectExpr); a287 4 REGISTER_MATCHER(unaryTransformType); REGISTER_MATCHER(unless); REGISTER_MATCHER(unresolvedConstructExpr); REGISTER_MATCHER(unresolvedUsingValueDecl); d309 4 a312 3 llvm::Optional Registry::lookupMatcherCtor(StringRef MatcherName, const SourceRange &NameRange, Diagnostics *Error) { d317 1 a317 1 return llvm::Optional(); d320 1 a320 9 return it->second; } // static VariantMatcher Registry::constructMatcher(MatcherCtor Ctor, const SourceRange &NameRange, ArrayRef Args, Diagnostics *Error) { return Ctor->create(NameRange, Args, Error); d324 1 a324 1 VariantMatcher Registry::constructBoundMatcher(MatcherCtor Ctor, d329 1 a329 1 VariantMatcher Out = constructMatcher(Ctor, NameRange, Args, Error); @ 1.1.1.3 log @Import Clang 3.5svn r199312 @ text @d16 3 a23 1 #include @ 1.1.1.4 log @Import Clang 3.5svn r201163. @ text @a20 1 #include a22 2 using namespace clang::ast_type_traits; a230 1 REGISTER_MATCHER(isListInitialization); a334 146 namespace { llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const std::set &KS) { unsigned Count = 0; for (std::set::const_iterator I = KS.begin(), E = KS.end(); I != E; ++I) { if (I != KS.begin()) OS << "|"; if (Count++ == 3) { OS << "..."; break; } OS << *I; } return OS; } struct ReverseSpecificityThenName { bool operator()(const std::pair &A, const std::pair &B) const { return A.first > B.first || (A.first == B.first && A.second < B.second); } }; } std::vector Registry::getCompletions( llvm::ArrayRef > Context) { ASTNodeKind InitialTypes[] = { ASTNodeKind::getFromNodeKind(), ASTNodeKind::getFromNodeKind(), ASTNodeKind::getFromNodeKind(), ASTNodeKind::getFromNodeKind(), ASTNodeKind::getFromNodeKind(), ASTNodeKind::getFromNodeKind(), ASTNodeKind::getFromNodeKind() }; llvm::ArrayRef InitialTypesRef(InitialTypes); // Starting with the above seed of acceptable top-level matcher types, compute // the acceptable type set for the argument indicated by each context element. std::set TypeSet(InitialTypesRef.begin(), InitialTypesRef.end()); for (llvm::ArrayRef >::iterator CtxI = Context.begin(), CtxE = Context.end(); CtxI != CtxE; ++CtxI) { std::vector NextTypeSet; for (std::set::iterator I = TypeSet.begin(), E = TypeSet.end(); I != E; ++I) { if (CtxI->first->isConvertibleTo(*I) && (CtxI->first->isVariadic() || CtxI->second < CtxI->first->getNumArgs())) CtxI->first->getArgKinds(*I, CtxI->second, NextTypeSet); } TypeSet.clear(); for (std::vector::iterator I = NextTypeSet.begin(), E = NextTypeSet.end(); I != E; ++I) { if (I->getArgKind() == internal::ArgKind::AK_Matcher) TypeSet.insert(I->getMatcherKind()); } } typedef std::map, MatcherCompletion, ReverseSpecificityThenName> CompletionsTy; CompletionsTy Completions; // TypeSet now contains the list of acceptable types for the argument we are // completing. Search the registry for acceptable matchers. for (ConstructorMap::const_iterator I = RegistryData->constructors().begin(), E = RegistryData->constructors().end(); I != E; ++I) { std::set RetKinds; unsigned NumArgs = I->second->isVariadic() ? 1 : I->second->getNumArgs(); bool IsPolymorphic = I->second->isPolymorphic(); std::vector > ArgsKinds(NumArgs); unsigned MaxSpecificity = 0; for (std::set::iterator TI = TypeSet.begin(), TE = TypeSet.end(); TI != TE; ++TI) { unsigned Specificity; ASTNodeKind LeastDerivedKind; if (I->second->isConvertibleTo(*TI, &Specificity, &LeastDerivedKind)) { if (MaxSpecificity < Specificity) MaxSpecificity = Specificity; RetKinds.insert(LeastDerivedKind); for (unsigned Arg = 0; Arg != NumArgs; ++Arg) I->second->getArgKinds(*TI, Arg, ArgsKinds[Arg]); if (IsPolymorphic) break; } } if (!RetKinds.empty() && MaxSpecificity > 0) { std::string Decl; llvm::raw_string_ostream OS(Decl); if (IsPolymorphic) { OS << "Matcher " << I->first() << "(Matcher"; } else { OS << "Matcher<" << RetKinds << "> " << I->first() << "("; for (std::vector >::iterator KI = ArgsKinds.begin(), KE = ArgsKinds.end(); KI != KE; ++KI) { if (KI != ArgsKinds.begin()) OS << ", "; // This currently assumes that a matcher may not overload a // non-matcher, and all non-matcher overloads have identical // arguments. if ((*KI)[0].getArgKind() == internal::ArgKind::AK_Matcher) { std::set MatcherKinds; std::transform( KI->begin(), KI->end(), std::inserter(MatcherKinds, MatcherKinds.end()), std::mem_fun_ref(&internal::ArgKind::getMatcherKind)); OS << "Matcher<" << MatcherKinds << ">"; } else { OS << (*KI)[0].asString(); } } } if (I->second->isVariadic()) OS << "..."; OS << ")"; std::string TypedText = I->first(); TypedText += "("; if (ArgsKinds.empty()) TypedText += ")"; else if (ArgsKinds[0][0].getArgKind() == internal::ArgKind::AK_String) TypedText += "\""; Completions[std::make_pair(MaxSpecificity, I->first())] = MatcherCompletion(TypedText, OS.str()); } } std::vector RetVal; for (CompletionsTy::iterator I = Completions.begin(), E = Completions.end(); I != E; ++I) RetVal.push_back(I->second); return RetVal; } @ 1.1.1.5 log @Import Clang 3.5svn r202566. @ text @a230 1 REGISTER_MATCHER(isExpr); @ 1.1.1.5.2.1 log @Rebase. @ text @d83 1 a91 1 REGISTER_OVERLOADED_2(loc); a151 1 REGISTER_MATCHER(exprWithCleanups); d327 3 a329 1 llvm::Optional Registry::lookupMatcherCtor(StringRef MatcherName) { d332 6 a337 3 return it == RegistryData->constructors().end() ? llvm::Optional() : it->second; @ 1.1.1.6 log @Import Clang 3.5svn r209886. @ text @d83 1 a91 1 REGISTER_OVERLOADED_2(loc); a151 1 REGISTER_MATCHER(exprWithCleanups); d327 3 a329 1 llvm::Optional Registry::lookupMatcherCtor(StringRef MatcherName) { d332 6 a337 3 return it == RegistryData->constructors().end() ? llvm::Optional() : it->second; @ 1.1.1.7 log @Import clang 3.6svn r215315. @ text @a191 1 REGISTER_MATCHER(hasGlobalStorage); a197 1 REGISTER_MATCHER(hasLocalStorage); d364 1 a364 1 ArrayRef > Context) { d374 1 a374 1 ArrayRef InitialTypesRef(InitialTypes); d379 1 a379 1 for (ArrayRef >::iterator @ 1.1.1.7.2.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @d104 1 a105 1 REGISTER_MATCHER(asString); d114 1 d126 1 a127 1 REGISTER_MATCHER(constCastExpr); a131 1 REGISTER_MATCHER(cStyleCastExpr); a132 1 REGISTER_MATCHER(CUDAKernelCallExpr); a133 1 REGISTER_MATCHER(declaratorDecl); d137 1 a149 1 REGISTER_MATCHER(equalsIntegralValue); a162 1 REGISTER_MATCHER(functionalCastExpr); d166 1 a177 1 REGISTER_MATCHER(hasAttr); d184 1 a185 1 REGISTER_MATCHER(hasDeclContext); a190 1 REGISTER_MATCHER(hasElse); a200 1 REGISTER_MATCHER(hasLoopVariable); a208 1 REGISTER_MATCHER(hasRangeInit); a215 1 REGISTER_MATCHER(hasThen); a232 1 REGISTER_MATCHER(isDeleted); a236 4 REGISTER_MATCHER(isExpansionInFileMatching); REGISTER_MATCHER(isExpansionInMainFile); REGISTER_MATCHER(isInstantiated); REGISTER_MATCHER(isExpansionInSystemHeader); a237 2 REGISTER_MATCHER(isIntegral); REGISTER_MATCHER(isInTemplateInstantiation); a242 1 REGISTER_MATCHER(isPure); d246 1 a248 1 REGISTER_MATCHER(lValueReferenceType); d257 1 a258 1 REGISTER_MATCHER(namesType); d274 1 a278 1 REGISTER_MATCHER(refersToIntegralType); d281 1 a282 2 REGISTER_MATCHER(returnStmt); REGISTER_MATCHER(rValueReferenceType); a290 1 REGISTER_MATCHER(substNonTypeTemplateParmExpr); a292 2 REGISTER_MATCHER(templateArgument); REGISTER_MATCHER(templateArgumentCountIs); d301 1 a301 1 REGISTER_MATCHER(typedefDecl); a302 1 REGISTER_MATCHER(typeLoc); a310 2 REGISTER_MATCHER(usingDirectiveDecl); REGISTER_MATCHER(valueDecl); a312 1 REGISTER_MATCHER(voidType); d356 8 a363 1 } // namespace d365 2 a366 2 std::vector Registry::getAcceptedCompletionTypes( ArrayRef> Context) { d368 9 a376 7 ASTNodeKind::getFromNodeKind(), ASTNodeKind::getFromNodeKind(), ASTNodeKind::getFromNodeKind(), ASTNodeKind::getFromNodeKind(), ASTNodeKind::getFromNodeKind(), ASTNodeKind::getFromNodeKind(), ASTNodeKind::getFromNodeKind()}; d380 12 a391 10 std::set TypeSet(std::begin(InitialTypes), std::end(InitialTypes)); for (const auto &CtxEntry : Context) { MatcherCtor Ctor = CtxEntry.first; unsigned ArgNumber = CtxEntry.second; std::vector NextTypeSet; for (const ArgKind &Kind : TypeSet) { if (Kind.getArgKind() == Kind.AK_Matcher && Ctor->isConvertibleTo(Kind.getMatcherKind()) && (Ctor->isVariadic() || ArgNumber < Ctor->getNumArgs())) Ctor->getArgKinds(Kind.getMatcherKind(), ArgNumber, NextTypeSet); d394 6 a399 1 TypeSet.insert(NextTypeSet.begin(), NextTypeSet.end()); a400 2 return std::vector(TypeSet.begin(), TypeSet.end()); } d402 3 a404 3 std::vector Registry::getMatcherCompletions(ArrayRef AcceptedTypes) { std::vector Completions; d406 2 a407 1 // Search the registry for acceptable matchers. d414 1 a414 1 std::vector> ArgsKinds(NumArgs); d416 3 a418 3 for (const ArgKind& Kind : AcceptedTypes) { if (Kind.getArgKind() != Kind.AK_Matcher) continue; d421 1 a421 2 if (I->second->isConvertibleTo(Kind.getMatcherKind(), &Specificity, &LeastDerivedKind)) { d426 1 a426 1 I->second->getArgKinds(Kind.getMatcherKind(), Arg, ArgsKinds[Arg]); d440 5 a444 2 for (const std::vector &Arg : ArgsKinds) { if (&Arg != &ArgsKinds[0]) d446 9 a454 15 bool FirstArgKind = true; std::set MatcherKinds; // Two steps. First all non-matchers, then matchers only. for (const ArgKind &AK : Arg) { if (AK.getArgKind() == ArgKind::AK_Matcher) { MatcherKinds.insert(AK.getMatcherKind()); } else { if (!FirstArgKind) OS << "|"; FirstArgKind = false; OS << AK.asString(); } } if (!MatcherKinds.empty()) { if (!FirstArgKind) OS << "|"; d456 2 d469 1 a469 1 else if (ArgsKinds[0][0].getArgKind() == ArgKind::AK_String) d472 2 a473 1 Completions.emplace_back(TypedText, OS.str(), MaxSpecificity); d477 5 a481 1 return Completions; @ 1.1.1.8 log @Import Clang 3.6RC1 r227398. @ text @d104 1 a105 1 REGISTER_MATCHER(asString); d114 1 d126 1 a127 1 REGISTER_MATCHER(constCastExpr); a131 1 REGISTER_MATCHER(cStyleCastExpr); a132 1 REGISTER_MATCHER(CUDAKernelCallExpr); a133 1 REGISTER_MATCHER(declaratorDecl); d137 1 a149 1 REGISTER_MATCHER(equalsIntegralValue); a162 1 REGISTER_MATCHER(functionalCastExpr); d166 1 a177 1 REGISTER_MATCHER(hasAttr); d184 1 a185 1 REGISTER_MATCHER(hasDeclContext); a190 1 REGISTER_MATCHER(hasElse); a200 1 REGISTER_MATCHER(hasLoopVariable); a208 1 REGISTER_MATCHER(hasRangeInit); a215 1 REGISTER_MATCHER(hasThen); a232 1 REGISTER_MATCHER(isDeleted); a236 4 REGISTER_MATCHER(isExpansionInFileMatching); REGISTER_MATCHER(isExpansionInMainFile); REGISTER_MATCHER(isInstantiated); REGISTER_MATCHER(isExpansionInSystemHeader); a237 2 REGISTER_MATCHER(isIntegral); REGISTER_MATCHER(isInTemplateInstantiation); a242 1 REGISTER_MATCHER(isPure); d246 1 a248 1 REGISTER_MATCHER(lValueReferenceType); d257 1 a258 1 REGISTER_MATCHER(namesType); d274 1 a278 1 REGISTER_MATCHER(refersToIntegralType); d281 1 a282 2 REGISTER_MATCHER(returnStmt); REGISTER_MATCHER(rValueReferenceType); a290 1 REGISTER_MATCHER(substNonTypeTemplateParmExpr); a292 2 REGISTER_MATCHER(templateArgument); REGISTER_MATCHER(templateArgumentCountIs); d301 1 a301 1 REGISTER_MATCHER(typedefDecl); a302 1 REGISTER_MATCHER(typeLoc); a310 2 REGISTER_MATCHER(usingDirectiveDecl); REGISTER_MATCHER(valueDecl); a312 1 REGISTER_MATCHER(voidType); d356 8 a363 1 } // namespace d365 2 a366 2 std::vector Registry::getAcceptedCompletionTypes( ArrayRef> Context) { d368 9 a376 7 ASTNodeKind::getFromNodeKind(), ASTNodeKind::getFromNodeKind(), ASTNodeKind::getFromNodeKind(), ASTNodeKind::getFromNodeKind(), ASTNodeKind::getFromNodeKind(), ASTNodeKind::getFromNodeKind(), ASTNodeKind::getFromNodeKind()}; d380 12 a391 10 std::set TypeSet(std::begin(InitialTypes), std::end(InitialTypes)); for (const auto &CtxEntry : Context) { MatcherCtor Ctor = CtxEntry.first; unsigned ArgNumber = CtxEntry.second; std::vector NextTypeSet; for (const ArgKind &Kind : TypeSet) { if (Kind.getArgKind() == Kind.AK_Matcher && Ctor->isConvertibleTo(Kind.getMatcherKind()) && (Ctor->isVariadic() || ArgNumber < Ctor->getNumArgs())) Ctor->getArgKinds(Kind.getMatcherKind(), ArgNumber, NextTypeSet); d394 6 a399 1 TypeSet.insert(NextTypeSet.begin(), NextTypeSet.end()); a400 2 return std::vector(TypeSet.begin(), TypeSet.end()); } d402 3 a404 3 std::vector Registry::getMatcherCompletions(ArrayRef AcceptedTypes) { std::vector Completions; d406 2 a407 1 // Search the registry for acceptable matchers. d414 1 a414 1 std::vector> ArgsKinds(NumArgs); d416 3 a418 3 for (const ArgKind& Kind : AcceptedTypes) { if (Kind.getArgKind() != Kind.AK_Matcher) continue; d421 1 a421 2 if (I->second->isConvertibleTo(Kind.getMatcherKind(), &Specificity, &LeastDerivedKind)) { d426 1 a426 1 I->second->getArgKinds(Kind.getMatcherKind(), Arg, ArgsKinds[Arg]); d440 5 a444 2 for (const std::vector &Arg : ArgsKinds) { if (&Arg != &ArgsKinds[0]) d446 9 a454 15 bool FirstArgKind = true; std::set MatcherKinds; // Two steps. First all non-matchers, then matchers only. for (const ArgKind &AK : Arg) { if (AK.getArgKind() == ArgKind::AK_Matcher) { MatcherKinds.insert(AK.getMatcherKind()); } else { if (!FirstArgKind) OS << "|"; FirstArgKind = false; OS << AK.asString(); } } if (!MatcherKinds.empty()) { if (!FirstArgKind) OS << "|"; d456 2 d469 1 a469 1 else if (ArgsKinds[0][0].getArgKind() == ArgKind::AK_String) d472 2 a473 1 Completions.emplace_back(TypedText, OS.str(), MaxSpecificity); d477 5 a481 1 return Completions; @ 1.1.1.9 log @Import Clang 3.8.0rc3 r261930. @ text @a17 1 #include "llvm/ADT/STLExtras.h" d109 1 d111 1 a111 1 REGISTER_MATCHER(booleanType); d117 1 d126 3 d132 2 a133 29 REGISTER_MATCHER(cudaKernelCallExpr); REGISTER_MATCHER(cxxBindTemporaryExpr); REGISTER_MATCHER(cxxBoolLiteral); REGISTER_MATCHER(cxxCatchStmt); REGISTER_MATCHER(cxxConstCastExpr); REGISTER_MATCHER(cxxConstructExpr); REGISTER_MATCHER(cxxConstructorDecl); REGISTER_MATCHER(cxxConversionDecl); REGISTER_MATCHER(cxxCtorInitializer); REGISTER_MATCHER(cxxDefaultArgExpr); REGISTER_MATCHER(cxxDeleteExpr); REGISTER_MATCHER(cxxDestructorDecl); REGISTER_MATCHER(cxxDynamicCastExpr); REGISTER_MATCHER(cxxForRangeStmt); REGISTER_MATCHER(cxxFunctionalCastExpr); REGISTER_MATCHER(cxxMemberCallExpr); REGISTER_MATCHER(cxxMethodDecl); REGISTER_MATCHER(cxxNewExpr); REGISTER_MATCHER(cxxNullPtrLiteralExpr); REGISTER_MATCHER(cxxOperatorCallExpr); REGISTER_MATCHER(cxxRecordDecl); REGISTER_MATCHER(cxxReinterpretCastExpr); REGISTER_MATCHER(cxxStaticCastExpr); REGISTER_MATCHER(cxxTemporaryObjectExpr); REGISTER_MATCHER(cxxThisExpr); REGISTER_MATCHER(cxxThrowExpr); REGISTER_MATCHER(cxxTryStmt); REGISTER_MATCHER(cxxUnresolvedConstructExpr); REGISTER_MATCHER(decayedType); d139 1 d141 1 d143 1 d145 1 d162 1 d165 1 a180 1 REGISTER_MATCHER(hasAutomaticStorageDuration); a186 1 REGISTER_MATCHER(hasDecayedType); a200 1 REGISTER_MATCHER(hasKeywordSelector); a207 1 REGISTER_MATCHER(hasNullSelector); a214 1 REGISTER_MATCHER(hasReceiverType); a215 1 REGISTER_MATCHER(hasSelector); a219 1 REGISTER_MATCHER(hasStaticStorageDuration); a222 1 REGISTER_MATCHER(hasThreadStorageDuration); a225 1 REGISTER_MATCHER(hasUnarySelector); a233 1 REGISTER_MATCHER(injectedClassNameType); a235 1 REGISTER_MATCHER(isAnonymous); a236 3 REGISTER_MATCHER(isBaseInitializer); REGISTER_MATCHER(isCatchAll); REGISTER_MATCHER(isClass); a238 2 REGISTER_MATCHER(isCopyConstructor); REGISTER_MATCHER(isDefaultConstructor); a240 2 REGISTER_MATCHER(isExceptionVariable); REGISTER_MATCHER(isExplicit); a243 2 REGISTER_MATCHER(isFinal); REGISTER_MATCHER(isInline); a252 3 REGISTER_MATCHER(isMemberInitializer); REGISTER_MATCHER(isMoveConstructor); REGISTER_MATCHER(isNoThrow); a257 1 REGISTER_MATCHER(isStruct); a258 2 REGISTER_MATCHER(isUnion); REGISTER_MATCHER(isVariadic); a259 1 REGISTER_MATCHER(isVolatileQualified); a264 1 REGISTER_MATCHER(matchesSelector); d267 1 d270 1 a271 1 REGISTER_MATCHER(namespaceAliasDecl); d276 2 a278 1 REGISTER_MATCHER(numSelectorArgs); a279 3 REGISTER_MATCHER(objcInterfaceDecl); REGISTER_MATCHER(objcMessageExpr); REGISTER_MATCHER(objcObjectPointerType); d282 1 d295 1 d304 1 a304 1 REGISTER_MATCHER(staticAssertDecl); a307 1 REGISTER_MATCHER(substTemplateTypeParmType); d313 2 a314 1 REGISTER_MATCHER(templateTypeParmType); d316 1 d318 1 a318 1 REGISTER_MATCHER(translationUnitDecl); d327 1 a327 1 REGISTER_MATCHER(unresolvedUsingTypenameDecl); d341 5 a345 1 llvm::DeleteContainerSeconds(Constructors); d416 3 a418 4 for (const auto &M : RegistryData->constructors()) { const auto *Matcher = M.getValue(); StringRef Name = M.getKey(); d420 2 a421 2 unsigned NumArgs = Matcher->isVariadic() ? 1 : Matcher->getNumArgs(); bool IsPolymorphic = Matcher->isPolymorphic(); d429 2 a430 2 if (Matcher->isConvertibleTo(Kind.getMatcherKind(), &Specificity, &LeastDerivedKind)) { d435 1 a435 1 Matcher->getArgKinds(Kind.getMatcherKind(), Arg, ArgsKinds[Arg]); d446 1 a446 1 OS << "Matcher " << Name << "(Matcher"; d448 1 a448 1 OS << "Matcher<" << RetKinds << "> " << Name << "("; d471 1 a471 1 if (Matcher->isVariadic()) d475 1 a475 1 std::string TypedText = Name; d491 1 a491 1 SourceRange NameRange, d499 1 a499 1 SourceRange NameRange, @ 1.1.1.9.2.1 log @Sync with HEAD @ text @d34 1 a34 1 typedef llvm::StringMap> ConstructorMap; d43 1 a43 3 void registerMatcher(StringRef MatcherName, std::unique_ptr Callback); d47 2 a48 2 void RegistryMaps::registerMatcher( StringRef MatcherName, std::unique_ptr Callback) { d50 1 a50 1 Constructors[MatcherName] = std::move(Callback); d58 1 a58 1 static_cast<::clang::ast_matchers::name##_Type##Id>( \ d63 8 a70 8 std::unique_ptr Callbacks[] = { \ internal::makeMatcherAutoMarshall(SPECIFIC_MATCHER_OVERLOAD(name, 0), \ #name), \ internal::makeMatcherAutoMarshall(SPECIFIC_MATCHER_OVERLOAD(name, 1), \ #name)}; \ registerMatcher( \ #name, \ llvm::make_unique(Callbacks)); \ a97 1 REGISTER_MATCHER(addrLabelExpr); a106 1 REGISTER_MATCHER(atomicExpr); a109 1 REGISTER_MATCHER(binaryConditionalOperator); a163 2 REGISTER_MATCHER(designatedInitExpr); REGISTER_MATCHER(designatorCountIs); a168 1 REGISTER_MATCHER(enumType); a176 1 REGISTER_MATCHER(forEachArgumentWithParam); a180 1 REGISTER_MATCHER(forFunction); a183 1 REGISTER_MATCHER(functionProtoType); a185 1 REGISTER_MATCHER(gnuNullExpr); a190 2 REGISTER_MATCHER(hasAnyDeclaration); REGISTER_MATCHER(hasAnyName); a199 1 REGISTER_MATCHER(hasBitWidth); a202 1 REGISTER_MATCHER(hasCastKind); a210 1 REGISTER_MATCHER(hasDynamicExceptionSpec); a213 1 REGISTER_MATCHER(hasExternalFormalLinkage); a216 1 REGISTER_MATCHER(hasInClassInitializer); a236 2 REGISTER_MATCHER(hasReplacementType); REGISTER_MATCHER(hasReturnValue); a243 1 REGISTER_MATCHER(hasSyntacticForm); a251 2 REGISTER_MATCHER(hasUnderlyingDecl); REGISTER_MATCHER(hasUnqualifiedDesugaredType); a253 1 REGISTER_MATCHER(ignoringImplicit); a256 1 REGISTER_MATCHER(ignoringParens); a257 1 REGISTER_MATCHER(implicitValueInitExpr); a263 2 REGISTER_MATCHER(isAnyCharacter); REGISTER_MATCHER(isAnyPointer); a265 1 REGISTER_MATCHER(isBitField); a269 1 REGISTER_MATCHER(isCopyAssignmentOperator); a271 1 REGISTER_MATCHER(isDefaulted); a288 1 REGISTER_MATCHER(isLambda); a290 1 REGISTER_MATCHER(isMoveAssignmentOperator); a297 1 REGISTER_MATCHER(isSignedInteger); a300 1 REGISTER_MATCHER(isUnsignedInteger); a302 1 REGISTER_MATCHER(isVirtualAsWritten); a304 1 REGISTER_MATCHER(labelDecl); a319 1 REGISTER_MATCHER(nullPointerConstant); a327 1 REGISTER_MATCHER(opaqueValueExpr); a328 2 REGISTER_MATCHER(parenExpr); REGISTER_MATCHER(parenListExpr); a332 1 REGISTER_MATCHER(predefinedExpr); a333 1 REGISTER_MATCHER(realFloatingPointType); a339 1 REGISTER_MATCHER(requiresZeroInitialization); a349 1 REGISTER_MATCHER(stmtExpr); a355 1 REGISTER_MATCHER(templateName); a357 1 REGISTER_MATCHER(templateTypeParmDecl); a363 1 REGISTER_MATCHER(typedefNameDecl); a364 1 REGISTER_MATCHER(typeAliasDecl); a369 1 REGISTER_MATCHER(unresolvedLookupExpr); d383 3 a385 1 RegistryMaps::~RegistryMaps() {} d393 2 a394 1 auto it = RegistryData->constructors().find(MatcherName); d397 1 a397 1 : it->second.get(); d456 1 a456 1 const MatcherDescriptor& Matcher = *M.getValue(); d460 2 a461 2 unsigned NumArgs = Matcher.isVariadic() ? 1 : Matcher.getNumArgs(); bool IsPolymorphic = Matcher.isPolymorphic(); d469 2 a470 2 if (Matcher.isConvertibleTo(Kind.getMatcherKind(), &Specificity, &LeastDerivedKind)) { d475 1 a475 1 Matcher.getArgKinds(Kind.getMatcherKind(), Arg, ArgsKinds[Arg]); d511 1 a511 1 if (Matcher.isVariadic()) @ 1.1.1.10 log @Import Clang pre-4.0.0 r291444. @ text @d34 1 a34 1 typedef llvm::StringMap> ConstructorMap; d43 1 a43 3 void registerMatcher(StringRef MatcherName, std::unique_ptr Callback); d47 2 a48 2 void RegistryMaps::registerMatcher( StringRef MatcherName, std::unique_ptr Callback) { d50 1 a50 1 Constructors[MatcherName] = std::move(Callback); d58 1 a58 1 static_cast<::clang::ast_matchers::name##_Type##Id>( \ d63 8 a70 8 std::unique_ptr Callbacks[] = { \ internal::makeMatcherAutoMarshall(SPECIFIC_MATCHER_OVERLOAD(name, 0), \ #name), \ internal::makeMatcherAutoMarshall(SPECIFIC_MATCHER_OVERLOAD(name, 1), \ #name)}; \ registerMatcher( \ #name, \ llvm::make_unique(Callbacks)); \ a97 1 REGISTER_MATCHER(addrLabelExpr); a106 1 REGISTER_MATCHER(atomicExpr); a109 1 REGISTER_MATCHER(binaryConditionalOperator); a163 2 REGISTER_MATCHER(designatedInitExpr); REGISTER_MATCHER(designatorCountIs); a168 1 REGISTER_MATCHER(enumType); a176 1 REGISTER_MATCHER(forEachArgumentWithParam); a180 1 REGISTER_MATCHER(forFunction); a183 1 REGISTER_MATCHER(functionProtoType); a185 1 REGISTER_MATCHER(gnuNullExpr); a190 2 REGISTER_MATCHER(hasAnyDeclaration); REGISTER_MATCHER(hasAnyName); a199 1 REGISTER_MATCHER(hasBitWidth); a202 1 REGISTER_MATCHER(hasCastKind); a210 1 REGISTER_MATCHER(hasDynamicExceptionSpec); a213 1 REGISTER_MATCHER(hasExternalFormalLinkage); a216 1 REGISTER_MATCHER(hasInClassInitializer); a236 2 REGISTER_MATCHER(hasReplacementType); REGISTER_MATCHER(hasReturnValue); a243 1 REGISTER_MATCHER(hasSyntacticForm); a251 2 REGISTER_MATCHER(hasUnderlyingDecl); REGISTER_MATCHER(hasUnqualifiedDesugaredType); a253 1 REGISTER_MATCHER(ignoringImplicit); a256 1 REGISTER_MATCHER(ignoringParens); a257 1 REGISTER_MATCHER(implicitValueInitExpr); a263 2 REGISTER_MATCHER(isAnyCharacter); REGISTER_MATCHER(isAnyPointer); a265 1 REGISTER_MATCHER(isBitField); a269 1 REGISTER_MATCHER(isCopyAssignmentOperator); a271 1 REGISTER_MATCHER(isDefaulted); a288 1 REGISTER_MATCHER(isLambda); a290 1 REGISTER_MATCHER(isMoveAssignmentOperator); a297 1 REGISTER_MATCHER(isSignedInteger); a300 1 REGISTER_MATCHER(isUnsignedInteger); a302 1 REGISTER_MATCHER(isVirtualAsWritten); a304 1 REGISTER_MATCHER(labelDecl); a319 1 REGISTER_MATCHER(nullPointerConstant); a327 1 REGISTER_MATCHER(opaqueValueExpr); a328 2 REGISTER_MATCHER(parenExpr); REGISTER_MATCHER(parenListExpr); a332 1 REGISTER_MATCHER(predefinedExpr); a333 1 REGISTER_MATCHER(realFloatingPointType); a339 1 REGISTER_MATCHER(requiresZeroInitialization); a349 1 REGISTER_MATCHER(stmtExpr); a355 1 REGISTER_MATCHER(templateName); a357 1 REGISTER_MATCHER(templateTypeParmDecl); a363 1 REGISTER_MATCHER(typedefNameDecl); a364 1 REGISTER_MATCHER(typeAliasDecl); a369 1 REGISTER_MATCHER(unresolvedLookupExpr); d383 3 a385 1 RegistryMaps::~RegistryMaps() {} d393 2 a394 1 auto it = RegistryData->constructors().find(MatcherName); d397 1 a397 1 : it->second.get(); d456 1 a456 1 const MatcherDescriptor& Matcher = *M.getValue(); d460 2 a461 2 unsigned NumArgs = Matcher.isVariadic() ? 1 : Matcher.getNumArgs(); bool IsPolymorphic = Matcher.isPolymorphic(); d469 2 a470 2 if (Matcher.isConvertibleTo(Kind.getMatcherKind(), &Specificity, &LeastDerivedKind)) { d475 1 a475 1 Matcher.getArgKinds(Kind.getMatcherKind(), Arg, ArgsKinds[Arg]); d511 1 a511 1 if (Matcher.isVariadic()) @ 1.1.1.11 log @Import clang r309604 from branches/release_50 @ text @a58 4 #define REGISTER_MATCHER_OVERLOAD(name) \ registerMatcher(#name, \ llvm::make_unique(name##Callbacks)) a62 4 #define MATCHER_OVERLOAD_ENTRY(name, Id) \ internal::makeMatcherAutoMarshall(SPECIFIC_MATCHER_OVERLOAD(name, Id), \ #name) d65 8 a72 4 std::unique_ptr name##Callbacks[] = { \ MATCHER_OVERLOAD_ENTRY(name, 0), \ MATCHER_OVERLOAD_ENTRY(name, 1)}; \ REGISTER_MATCHER_OVERLOAD(name); \ d86 1 a98 7 std::unique_ptr equalsCallbacks[] = { MATCHER_OVERLOAD_ENTRY(equals, 0), MATCHER_OVERLOAD_ENTRY(equals, 1), MATCHER_OVERLOAD_ENTRY(equals, 2), }; REGISTER_MATCHER_OVERLOAD(equals); a155 1 REGISTER_MATCHER(cxxStdInitializerListExpr); a298 1 REGISTER_MATCHER(isConstexpr); a332 1 REGISTER_MATCHER(isStaticStorageClass); a361 1 REGISTER_MATCHER(objcCategoryDecl); a362 1 REGISTER_MATCHER(objcIvarDecl); a363 1 REGISTER_MATCHER(objcMethodDecl); a364 2 REGISTER_MATCHER(objcPropertyDecl); REGISTER_MATCHER(objcProtocolDecl); a414 1 REGISTER_MATCHER(typeAliasTemplateDecl); @ 1.1.1.11.4.1 log @Sync with HEAD @ text @d1 1 a1 1 //===- Registry.cpp - Matcher registry ------------------------------------===// d8 2 a9 2 //===----------------------------------------------------------------------===// // d11 3 a13 3 /// Registry map populated at static initialization time. // //===----------------------------------------------------------------------===// a16 1 #include "clang/AST/ASTTypeTraits.h" a17 3 #include "clang/ASTMatchers/Dynamic/Diagnostics.h" #include "clang/ASTMatchers/Dynamic/VariantValue.h" #include "llvm/ADT/Optional.h" a21 4 #include "llvm/Support/raw_ostream.h" #include #include #include a22 1 #include a23 1 #include a29 1 d34 1 a34 2 using ConstructorMap = llvm::StringMap>; a48 2 } // namespace d77 1 a77 1 } while (false) d79 1 a79 1 /// Generate a registry map with all the known matchers. a122 1 REGISTER_MATCHER(autoreleasePoolStmt) a124 1 REGISTER_MATCHER(blockDecl); a198 1 REGISTER_MATCHER(forEachOverridden); a221 1 REGISTER_MATCHER(hasArraySize); a235 2 REGISTER_MATCHER(hasDefaultArgument); REGISTER_MATCHER(hasDefinition); a265 1 REGISTER_MATCHER(hasReceiver); a270 1 REGISTER_MATCHER(hasAnySelector); a280 1 REGISTER_MATCHER(hasTrailingReturn); a303 1 REGISTER_MATCHER(isArray); a304 1 REGISTER_MATCHER(isAssignmentOperator); a327 1 REGISTER_MATCHER(isInstanceMessage); a337 1 REGISTER_MATCHER(isNoReturn); a343 1 REGISTER_MATCHER(isScoped); a357 1 REGISTER_MATCHER(linkageSpecDecl); a374 1 REGISTER_MATCHER(objcCatchStmt); a375 3 REGISTER_MATCHER(objcCategoryImplDecl); REGISTER_MATCHER(objcFinallyStmt); REGISTER_MATCHER(objcImplementationDecl); a382 2 REGISTER_MATCHER(objcThrowStmt); REGISTER_MATCHER(objcTryStmt); d453 1 a453 1 RegistryMaps::~RegistryMaps() = default; d457 2 d467 4 a470 2 static llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const std::set &KS) { d485 2 d596 1 d604 1 d624 3 a626 3 } // namespace dynamic } // namespace ast_matchers } // namespace clang @ 1.1.1.11.4.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.11.2.1 log @Sync with HEAD @ text @d1 1 a1 1 //===- Registry.cpp - Matcher registry ------------------------------------===// d8 2 a9 2 //===----------------------------------------------------------------------===// // d11 3 a13 3 /// Registry map populated at static initialization time. // //===----------------------------------------------------------------------===// a16 1 #include "clang/AST/ASTTypeTraits.h" a17 3 #include "clang/ASTMatchers/Dynamic/Diagnostics.h" #include "clang/ASTMatchers/Dynamic/VariantValue.h" #include "llvm/ADT/Optional.h" a21 4 #include "llvm/Support/raw_ostream.h" #include #include #include a22 1 #include a23 1 #include a29 1 d34 1 a34 2 using ConstructorMap = llvm::StringMap>; a48 2 } // namespace d77 1 a77 1 } while (false) d79 1 a79 1 /// Generate a registry map with all the known matchers. a122 1 REGISTER_MATCHER(autoreleasePoolStmt) a124 1 REGISTER_MATCHER(blockDecl); a198 1 REGISTER_MATCHER(forEachOverridden); a221 1 REGISTER_MATCHER(hasArraySize); a235 2 REGISTER_MATCHER(hasDefaultArgument); REGISTER_MATCHER(hasDefinition); a265 1 REGISTER_MATCHER(hasReceiver); a270 1 REGISTER_MATCHER(hasAnySelector); a280 1 REGISTER_MATCHER(hasTrailingReturn); a303 1 REGISTER_MATCHER(isArray); a304 1 REGISTER_MATCHER(isAssignmentOperator); a327 1 REGISTER_MATCHER(isInstanceMessage); a337 1 REGISTER_MATCHER(isNoReturn); a343 1 REGISTER_MATCHER(isScoped); a357 1 REGISTER_MATCHER(linkageSpecDecl); a374 1 REGISTER_MATCHER(objcCatchStmt); a375 3 REGISTER_MATCHER(objcCategoryImplDecl); REGISTER_MATCHER(objcFinallyStmt); REGISTER_MATCHER(objcImplementationDecl); a382 2 REGISTER_MATCHER(objcThrowStmt); REGISTER_MATCHER(objcTryStmt); d453 1 a453 1 RegistryMaps::~RegistryMaps() = default; d457 2 d467 4 a470 2 static llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const std::set &KS) { d485 2 d596 1 d604 1 d624 3 a626 3 } // namespace dynamic } // namespace ast_matchers } // namespace clang @ 1.1.1.12 log @Import clang r337282 from trunk @ text @d1 1 a1 1 //===- Registry.cpp - Matcher registry ------------------------------------===// d8 2 a9 2 //===----------------------------------------------------------------------===// // d11 3 a13 3 /// Registry map populated at static initialization time. // //===----------------------------------------------------------------------===// a16 1 #include "clang/AST/ASTTypeTraits.h" a17 3 #include "clang/ASTMatchers/Dynamic/Diagnostics.h" #include "clang/ASTMatchers/Dynamic/VariantValue.h" #include "llvm/ADT/Optional.h" a21 4 #include "llvm/Support/raw_ostream.h" #include #include #include a22 1 #include a23 1 #include a29 1 d34 1 a34 2 using ConstructorMap = llvm::StringMap>; a48 2 } // namespace d77 1 a77 1 } while (false) d79 1 a79 1 /// Generate a registry map with all the known matchers. a122 1 REGISTER_MATCHER(autoreleasePoolStmt) a124 1 REGISTER_MATCHER(blockDecl); a198 1 REGISTER_MATCHER(forEachOverridden); a221 1 REGISTER_MATCHER(hasArraySize); a235 2 REGISTER_MATCHER(hasDefaultArgument); REGISTER_MATCHER(hasDefinition); a265 1 REGISTER_MATCHER(hasReceiver); a270 1 REGISTER_MATCHER(hasAnySelector); a280 1 REGISTER_MATCHER(hasTrailingReturn); a303 1 REGISTER_MATCHER(isArray); a304 1 REGISTER_MATCHER(isAssignmentOperator); a327 1 REGISTER_MATCHER(isInstanceMessage); a337 1 REGISTER_MATCHER(isNoReturn); a343 1 REGISTER_MATCHER(isScoped); a357 1 REGISTER_MATCHER(linkageSpecDecl); a374 1 REGISTER_MATCHER(objcCatchStmt); a375 3 REGISTER_MATCHER(objcCategoryImplDecl); REGISTER_MATCHER(objcFinallyStmt); REGISTER_MATCHER(objcImplementationDecl); a382 2 REGISTER_MATCHER(objcThrowStmt); REGISTER_MATCHER(objcTryStmt); d453 1 a453 1 RegistryMaps::~RegistryMaps() = default; d457 2 d467 4 a470 2 static llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const std::set &KS) { d485 2 d596 1 d604 1 d624 3 a626 3 } // namespace dynamic } // namespace ast_matchers } // namespace clang @ 1.1.1.13 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.7.4.1 log @file Registry.cpp was added on branch tls-maxphys on 2014-08-19 23:47:26 +0000 @ text @d1 514 @ 1.1.1.7.4.2 log @Rebase to HEAD as of a few days ago. @ text @a0 514 //===--- Registry.cpp - Matcher registry -------------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===------------------------------------------------------------===// /// /// \file /// \brief Registry map populated at static initialization time. /// //===------------------------------------------------------------===// #include "clang/ASTMatchers/Dynamic/Registry.h" #include "Marshallers.h" #include "clang/ASTMatchers/ASTMatchers.h" #include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringRef.h" #include "llvm/Support/ManagedStatic.h" #include #include using namespace clang::ast_type_traits; namespace clang { namespace ast_matchers { namespace dynamic { namespace { using internal::MatcherDescriptor; typedef llvm::StringMap ConstructorMap; class RegistryMaps { public: RegistryMaps(); ~RegistryMaps(); const ConstructorMap &constructors() const { return Constructors; } private: void registerMatcher(StringRef MatcherName, MatcherDescriptor *Callback); ConstructorMap Constructors; }; void RegistryMaps::registerMatcher(StringRef MatcherName, MatcherDescriptor *Callback) { assert(Constructors.find(MatcherName) == Constructors.end()); Constructors[MatcherName] = Callback; } #define REGISTER_MATCHER(name) \ registerMatcher(#name, internal::makeMatcherAutoMarshall( \ ::clang::ast_matchers::name, #name)); #define SPECIFIC_MATCHER_OVERLOAD(name, Id) \ static_cast< ::clang::ast_matchers::name##_Type##Id>( \ ::clang::ast_matchers::name) #define REGISTER_OVERLOADED_2(name) \ do { \ MatcherDescriptor *Callbacks[] = { \ internal::makeMatcherAutoMarshall(SPECIFIC_MATCHER_OVERLOAD(name, 0), \ #name), \ internal::makeMatcherAutoMarshall(SPECIFIC_MATCHER_OVERLOAD(name, 1), \ #name) \ }; \ registerMatcher(#name, \ new internal::OverloadedMatcherDescriptor(Callbacks)); \ } while (0) /// \brief Generate a registry map with all the known matchers. RegistryMaps::RegistryMaps() { // TODO: Here is the list of the missing matchers, grouped by reason. // // Need Variant/Parser fixes: // ofKind // // Polymorphic + argument overload: // findAll // // Other: // equals // equalsNode REGISTER_OVERLOADED_2(callee); REGISTER_OVERLOADED_2(hasPrefix); REGISTER_OVERLOADED_2(hasType); REGISTER_OVERLOADED_2(isDerivedFrom); REGISTER_OVERLOADED_2(isSameOrDerivedFrom); REGISTER_OVERLOADED_2(loc); REGISTER_OVERLOADED_2(pointsTo); REGISTER_OVERLOADED_2(references); REGISTER_OVERLOADED_2(thisPointerType); REGISTER_MATCHER(accessSpecDecl); REGISTER_MATCHER(alignOfExpr); REGISTER_MATCHER(allOf); REGISTER_MATCHER(anyOf); REGISTER_MATCHER(anything); REGISTER_MATCHER(argumentCountIs); REGISTER_MATCHER(arraySubscriptExpr); REGISTER_MATCHER(arrayType); REGISTER_MATCHER(asString); REGISTER_MATCHER(asmStmt); REGISTER_MATCHER(atomicType); REGISTER_MATCHER(autoType); REGISTER_MATCHER(binaryOperator); REGISTER_MATCHER(bindTemporaryExpr); REGISTER_MATCHER(blockPointerType); REGISTER_MATCHER(boolLiteral); REGISTER_MATCHER(breakStmt); REGISTER_MATCHER(builtinType); REGISTER_MATCHER(cStyleCastExpr); REGISTER_MATCHER(callExpr); REGISTER_MATCHER(caseStmt); REGISTER_MATCHER(castExpr); REGISTER_MATCHER(catchStmt); REGISTER_MATCHER(characterLiteral); REGISTER_MATCHER(classTemplateDecl); REGISTER_MATCHER(classTemplateSpecializationDecl); REGISTER_MATCHER(complexType); REGISTER_MATCHER(compoundLiteralExpr); REGISTER_MATCHER(compoundStmt); REGISTER_MATCHER(conditionalOperator); REGISTER_MATCHER(constCastExpr); REGISTER_MATCHER(constantArrayType); REGISTER_MATCHER(constructExpr); REGISTER_MATCHER(constructorDecl); REGISTER_MATCHER(containsDeclaration); REGISTER_MATCHER(continueStmt); REGISTER_MATCHER(ctorInitializer); REGISTER_MATCHER(decl); REGISTER_MATCHER(declCountIs); REGISTER_MATCHER(declRefExpr); REGISTER_MATCHER(declStmt); REGISTER_MATCHER(declaratorDecl); REGISTER_MATCHER(defaultArgExpr); REGISTER_MATCHER(defaultStmt); REGISTER_MATCHER(deleteExpr); REGISTER_MATCHER(dependentSizedArrayType); REGISTER_MATCHER(destructorDecl); REGISTER_MATCHER(doStmt); REGISTER_MATCHER(dynamicCastExpr); REGISTER_MATCHER(eachOf); REGISTER_MATCHER(elaboratedType); REGISTER_MATCHER(enumConstantDecl); REGISTER_MATCHER(enumDecl); REGISTER_MATCHER(equalsBoundNode); REGISTER_MATCHER(explicitCastExpr); REGISTER_MATCHER(expr); REGISTER_MATCHER(exprWithCleanups); REGISTER_MATCHER(fieldDecl); REGISTER_MATCHER(floatLiteral); REGISTER_MATCHER(forEach); REGISTER_MATCHER(forEachConstructorInitializer); REGISTER_MATCHER(forEachDescendant); REGISTER_MATCHER(forEachSwitchCase); REGISTER_MATCHER(forField); REGISTER_MATCHER(forRangeStmt); REGISTER_MATCHER(forStmt); REGISTER_MATCHER(friendDecl); REGISTER_MATCHER(functionDecl); REGISTER_MATCHER(functionTemplateDecl); REGISTER_MATCHER(functionType); REGISTER_MATCHER(functionalCastExpr); REGISTER_MATCHER(gotoStmt); REGISTER_MATCHER(has); REGISTER_MATCHER(hasAncestor); REGISTER_MATCHER(hasAnyArgument); REGISTER_MATCHER(hasAnyConstructorInitializer); REGISTER_MATCHER(hasAnyParameter); REGISTER_MATCHER(hasAnySubstatement); REGISTER_MATCHER(hasAnyTemplateArgument); REGISTER_MATCHER(hasAnyUsingShadowDecl); REGISTER_MATCHER(hasArgument); REGISTER_MATCHER(hasArgumentOfType); REGISTER_MATCHER(hasBase); REGISTER_MATCHER(hasBody); REGISTER_MATCHER(hasCanonicalType); REGISTER_MATCHER(hasCaseConstant); REGISTER_MATCHER(hasCondition); REGISTER_MATCHER(hasConditionVariableStatement); REGISTER_MATCHER(hasDeclContext); REGISTER_MATCHER(hasDeclaration); REGISTER_MATCHER(hasDeducedType); REGISTER_MATCHER(hasDescendant); REGISTER_MATCHER(hasDestinationType); REGISTER_MATCHER(hasEitherOperand); REGISTER_MATCHER(hasElementType); REGISTER_MATCHER(hasFalseExpression); REGISTER_MATCHER(hasGlobalStorage); REGISTER_MATCHER(hasImplicitDestinationType); REGISTER_MATCHER(hasIncrement); REGISTER_MATCHER(hasIndex); REGISTER_MATCHER(hasInitializer); REGISTER_MATCHER(hasLHS); REGISTER_MATCHER(hasLocalQualifiers); REGISTER_MATCHER(hasLocalStorage); REGISTER_MATCHER(hasLoopInit); REGISTER_MATCHER(hasMethod); REGISTER_MATCHER(hasName); REGISTER_MATCHER(hasObjectExpression); REGISTER_MATCHER(hasOperatorName); REGISTER_MATCHER(hasOverloadedOperatorName); REGISTER_MATCHER(hasParameter); REGISTER_MATCHER(hasParent); REGISTER_MATCHER(hasQualifier); REGISTER_MATCHER(hasRHS); REGISTER_MATCHER(hasSingleDecl); REGISTER_MATCHER(hasSize); REGISTER_MATCHER(hasSizeExpr); REGISTER_MATCHER(hasSourceExpression); REGISTER_MATCHER(hasTargetDecl); REGISTER_MATCHER(hasTemplateArgument); REGISTER_MATCHER(hasTrueExpression); REGISTER_MATCHER(hasTypeLoc); REGISTER_MATCHER(hasUnaryOperand); REGISTER_MATCHER(hasValueType); REGISTER_MATCHER(ifStmt); REGISTER_MATCHER(ignoringImpCasts); REGISTER_MATCHER(ignoringParenCasts); REGISTER_MATCHER(ignoringParenImpCasts); REGISTER_MATCHER(implicitCastExpr); REGISTER_MATCHER(incompleteArrayType); REGISTER_MATCHER(initListExpr); REGISTER_MATCHER(innerType); REGISTER_MATCHER(integerLiteral); REGISTER_MATCHER(isArrow); REGISTER_MATCHER(isConst); REGISTER_MATCHER(isConstQualified); REGISTER_MATCHER(isDefinition); REGISTER_MATCHER(isExplicitTemplateSpecialization); REGISTER_MATCHER(isExpr); REGISTER_MATCHER(isExternC); REGISTER_MATCHER(isImplicit); REGISTER_MATCHER(isInteger); REGISTER_MATCHER(isListInitialization); REGISTER_MATCHER(isOverride); REGISTER_MATCHER(isPrivate); REGISTER_MATCHER(isProtected); REGISTER_MATCHER(isPublic); REGISTER_MATCHER(isTemplateInstantiation); REGISTER_MATCHER(isVirtual); REGISTER_MATCHER(isWritten); REGISTER_MATCHER(lValueReferenceType); REGISTER_MATCHER(labelStmt); REGISTER_MATCHER(lambdaExpr); REGISTER_MATCHER(matchesName); REGISTER_MATCHER(materializeTemporaryExpr); REGISTER_MATCHER(member); REGISTER_MATCHER(memberCallExpr); REGISTER_MATCHER(memberExpr); REGISTER_MATCHER(memberPointerType); REGISTER_MATCHER(methodDecl); REGISTER_MATCHER(namedDecl); REGISTER_MATCHER(namesType); REGISTER_MATCHER(namespaceDecl); REGISTER_MATCHER(nestedNameSpecifier); REGISTER_MATCHER(nestedNameSpecifierLoc); REGISTER_MATCHER(newExpr); REGISTER_MATCHER(nullPtrLiteralExpr); REGISTER_MATCHER(nullStmt); REGISTER_MATCHER(ofClass); REGISTER_MATCHER(on); REGISTER_MATCHER(onImplicitObjectArgument); REGISTER_MATCHER(operatorCallExpr); REGISTER_MATCHER(parameterCountIs); REGISTER_MATCHER(parenType); REGISTER_MATCHER(parmVarDecl); REGISTER_MATCHER(pointee); REGISTER_MATCHER(pointerType); REGISTER_MATCHER(qualType); REGISTER_MATCHER(rValueReferenceType); REGISTER_MATCHER(recordDecl); REGISTER_MATCHER(recordType); REGISTER_MATCHER(referenceType); REGISTER_MATCHER(refersToDeclaration); REGISTER_MATCHER(refersToType); REGISTER_MATCHER(reinterpretCastExpr); REGISTER_MATCHER(returnStmt); REGISTER_MATCHER(returns); REGISTER_MATCHER(sizeOfExpr); REGISTER_MATCHER(specifiesNamespace); REGISTER_MATCHER(specifiesType); REGISTER_MATCHER(specifiesTypeLoc); REGISTER_MATCHER(statementCountIs); REGISTER_MATCHER(staticCastExpr); REGISTER_MATCHER(stmt); REGISTER_MATCHER(stringLiteral); REGISTER_MATCHER(switchCase); REGISTER_MATCHER(switchStmt); REGISTER_MATCHER(templateSpecializationType); REGISTER_MATCHER(temporaryObjectExpr); REGISTER_MATCHER(thisExpr); REGISTER_MATCHER(throughUsingDecl); REGISTER_MATCHER(throwExpr); REGISTER_MATCHER(to); REGISTER_MATCHER(tryStmt); REGISTER_MATCHER(type); REGISTER_MATCHER(typeLoc); REGISTER_MATCHER(typedefType); REGISTER_MATCHER(unaryExprOrTypeTraitExpr); REGISTER_MATCHER(unaryOperator); REGISTER_MATCHER(unaryTransformType); REGISTER_MATCHER(unless); REGISTER_MATCHER(unresolvedConstructExpr); REGISTER_MATCHER(unresolvedUsingValueDecl); REGISTER_MATCHER(userDefinedLiteral); REGISTER_MATCHER(usingDecl); REGISTER_MATCHER(varDecl); REGISTER_MATCHER(variableArrayType); REGISTER_MATCHER(whileStmt); REGISTER_MATCHER(withInitializer); } RegistryMaps::~RegistryMaps() { for (ConstructorMap::iterator it = Constructors.begin(), end = Constructors.end(); it != end; ++it) { delete it->second; } } static llvm::ManagedStatic RegistryData; } // anonymous namespace // static llvm::Optional Registry::lookupMatcherCtor(StringRef MatcherName) { ConstructorMap::const_iterator it = RegistryData->constructors().find(MatcherName); return it == RegistryData->constructors().end() ? llvm::Optional() : it->second; } namespace { llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const std::set &KS) { unsigned Count = 0; for (std::set::const_iterator I = KS.begin(), E = KS.end(); I != E; ++I) { if (I != KS.begin()) OS << "|"; if (Count++ == 3) { OS << "..."; break; } OS << *I; } return OS; } struct ReverseSpecificityThenName { bool operator()(const std::pair &A, const std::pair &B) const { return A.first > B.first || (A.first == B.first && A.second < B.second); } }; } std::vector Registry::getCompletions( ArrayRef > Context) { ASTNodeKind InitialTypes[] = { ASTNodeKind::getFromNodeKind(), ASTNodeKind::getFromNodeKind(), ASTNodeKind::getFromNodeKind(), ASTNodeKind::getFromNodeKind(), ASTNodeKind::getFromNodeKind(), ASTNodeKind::getFromNodeKind(), ASTNodeKind::getFromNodeKind() }; ArrayRef InitialTypesRef(InitialTypes); // Starting with the above seed of acceptable top-level matcher types, compute // the acceptable type set for the argument indicated by each context element. std::set TypeSet(InitialTypesRef.begin(), InitialTypesRef.end()); for (ArrayRef >::iterator CtxI = Context.begin(), CtxE = Context.end(); CtxI != CtxE; ++CtxI) { std::vector NextTypeSet; for (std::set::iterator I = TypeSet.begin(), E = TypeSet.end(); I != E; ++I) { if (CtxI->first->isConvertibleTo(*I) && (CtxI->first->isVariadic() || CtxI->second < CtxI->first->getNumArgs())) CtxI->first->getArgKinds(*I, CtxI->second, NextTypeSet); } TypeSet.clear(); for (std::vector::iterator I = NextTypeSet.begin(), E = NextTypeSet.end(); I != E; ++I) { if (I->getArgKind() == internal::ArgKind::AK_Matcher) TypeSet.insert(I->getMatcherKind()); } } typedef std::map, MatcherCompletion, ReverseSpecificityThenName> CompletionsTy; CompletionsTy Completions; // TypeSet now contains the list of acceptable types for the argument we are // completing. Search the registry for acceptable matchers. for (ConstructorMap::const_iterator I = RegistryData->constructors().begin(), E = RegistryData->constructors().end(); I != E; ++I) { std::set RetKinds; unsigned NumArgs = I->second->isVariadic() ? 1 : I->second->getNumArgs(); bool IsPolymorphic = I->second->isPolymorphic(); std::vector > ArgsKinds(NumArgs); unsigned MaxSpecificity = 0; for (std::set::iterator TI = TypeSet.begin(), TE = TypeSet.end(); TI != TE; ++TI) { unsigned Specificity; ASTNodeKind LeastDerivedKind; if (I->second->isConvertibleTo(*TI, &Specificity, &LeastDerivedKind)) { if (MaxSpecificity < Specificity) MaxSpecificity = Specificity; RetKinds.insert(LeastDerivedKind); for (unsigned Arg = 0; Arg != NumArgs; ++Arg) I->second->getArgKinds(*TI, Arg, ArgsKinds[Arg]); if (IsPolymorphic) break; } } if (!RetKinds.empty() && MaxSpecificity > 0) { std::string Decl; llvm::raw_string_ostream OS(Decl); if (IsPolymorphic) { OS << "Matcher " << I->first() << "(Matcher"; } else { OS << "Matcher<" << RetKinds << "> " << I->first() << "("; for (std::vector >::iterator KI = ArgsKinds.begin(), KE = ArgsKinds.end(); KI != KE; ++KI) { if (KI != ArgsKinds.begin()) OS << ", "; // This currently assumes that a matcher may not overload a // non-matcher, and all non-matcher overloads have identical // arguments. if ((*KI)[0].getArgKind() == internal::ArgKind::AK_Matcher) { std::set MatcherKinds; std::transform( KI->begin(), KI->end(), std::inserter(MatcherKinds, MatcherKinds.end()), std::mem_fun_ref(&internal::ArgKind::getMatcherKind)); OS << "Matcher<" << MatcherKinds << ">"; } else { OS << (*KI)[0].asString(); } } } if (I->second->isVariadic()) OS << "..."; OS << ")"; std::string TypedText = I->first(); TypedText += "("; if (ArgsKinds.empty()) TypedText += ")"; else if (ArgsKinds[0][0].getArgKind() == internal::ArgKind::AK_String) TypedText += "\""; Completions[std::make_pair(MaxSpecificity, I->first())] = MatcherCompletion(TypedText, OS.str()); } } std::vector RetVal; for (CompletionsTy::iterator I = Completions.begin(), E = Completions.end(); I != E; ++I) RetVal.push_back(I->second); return RetVal; } // static VariantMatcher Registry::constructMatcher(MatcherCtor Ctor, const SourceRange &NameRange, ArrayRef Args, Diagnostics *Error) { return Ctor->create(NameRange, Args, Error); } // static VariantMatcher Registry::constructBoundMatcher(MatcherCtor Ctor, const SourceRange &NameRange, StringRef BindID, ArrayRef Args, Diagnostics *Error) { VariantMatcher Out = constructMatcher(Ctor, NameRange, Args, Error); if (Out.isNull()) return Out; llvm::Optional Result = Out.getSingleMatcher(); if (Result.hasValue()) { llvm::Optional Bound = Result->tryBind(BindID); if (Bound.hasValue()) { return VariantMatcher::SingleMatcher(*Bound); } } Error->addError(NameRange, Error->ET_RegistryNotBindable); return VariantMatcher(); } } // namespace dynamic } // namespace ast_matchers } // namespace clang @ 1.1.1.5.4.1 log @file Registry.cpp was added on branch yamt-pagecache on 2014-05-22 16:18:26 +0000 @ text @d1 516 @ 1.1.1.5.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 516 //===--- Registry.cpp - Matcher registry -------------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===------------------------------------------------------------===// /// /// \file /// \brief Registry map populated at static initialization time. /// //===------------------------------------------------------------===// #include "clang/ASTMatchers/Dynamic/Registry.h" #include "Marshallers.h" #include "clang/ASTMatchers/ASTMatchers.h" #include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringRef.h" #include "llvm/Support/ManagedStatic.h" #include #include using namespace clang::ast_type_traits; namespace clang { namespace ast_matchers { namespace dynamic { namespace { using internal::MatcherDescriptor; typedef llvm::StringMap ConstructorMap; class RegistryMaps { public: RegistryMaps(); ~RegistryMaps(); const ConstructorMap &constructors() const { return Constructors; } private: void registerMatcher(StringRef MatcherName, MatcherDescriptor *Callback); ConstructorMap Constructors; }; void RegistryMaps::registerMatcher(StringRef MatcherName, MatcherDescriptor *Callback) { assert(Constructors.find(MatcherName) == Constructors.end()); Constructors[MatcherName] = Callback; } #define REGISTER_MATCHER(name) \ registerMatcher(#name, internal::makeMatcherAutoMarshall( \ ::clang::ast_matchers::name, #name)); #define SPECIFIC_MATCHER_OVERLOAD(name, Id) \ static_cast< ::clang::ast_matchers::name##_Type##Id>( \ ::clang::ast_matchers::name) #define REGISTER_OVERLOADED_2(name) \ do { \ MatcherDescriptor *Callbacks[] = { \ internal::makeMatcherAutoMarshall(SPECIFIC_MATCHER_OVERLOAD(name, 0), \ #name), \ internal::makeMatcherAutoMarshall(SPECIFIC_MATCHER_OVERLOAD(name, 1), \ #name) \ }; \ registerMatcher(#name, \ new internal::OverloadedMatcherDescriptor(Callbacks)); \ } while (0) /// \brief Generate a registry map with all the known matchers. RegistryMaps::RegistryMaps() { // TODO: Here is the list of the missing matchers, grouped by reason. // // Need Variant/Parser fixes: // ofKind // // Polymorphic + argument overload: // findAll // // Other: // loc // equals // equalsNode REGISTER_OVERLOADED_2(callee); REGISTER_OVERLOADED_2(hasPrefix); REGISTER_OVERLOADED_2(hasType); REGISTER_OVERLOADED_2(isDerivedFrom); REGISTER_OVERLOADED_2(isSameOrDerivedFrom); REGISTER_OVERLOADED_2(pointsTo); REGISTER_OVERLOADED_2(references); REGISTER_OVERLOADED_2(thisPointerType); REGISTER_MATCHER(accessSpecDecl); REGISTER_MATCHER(alignOfExpr); REGISTER_MATCHER(allOf); REGISTER_MATCHER(anyOf); REGISTER_MATCHER(anything); REGISTER_MATCHER(argumentCountIs); REGISTER_MATCHER(arraySubscriptExpr); REGISTER_MATCHER(arrayType); REGISTER_MATCHER(asString); REGISTER_MATCHER(asmStmt); REGISTER_MATCHER(atomicType); REGISTER_MATCHER(autoType); REGISTER_MATCHER(binaryOperator); REGISTER_MATCHER(bindTemporaryExpr); REGISTER_MATCHER(blockPointerType); REGISTER_MATCHER(boolLiteral); REGISTER_MATCHER(breakStmt); REGISTER_MATCHER(builtinType); REGISTER_MATCHER(cStyleCastExpr); REGISTER_MATCHER(callExpr); REGISTER_MATCHER(caseStmt); REGISTER_MATCHER(castExpr); REGISTER_MATCHER(catchStmt); REGISTER_MATCHER(characterLiteral); REGISTER_MATCHER(classTemplateDecl); REGISTER_MATCHER(classTemplateSpecializationDecl); REGISTER_MATCHER(complexType); REGISTER_MATCHER(compoundLiteralExpr); REGISTER_MATCHER(compoundStmt); REGISTER_MATCHER(conditionalOperator); REGISTER_MATCHER(constCastExpr); REGISTER_MATCHER(constantArrayType); REGISTER_MATCHER(constructExpr); REGISTER_MATCHER(constructorDecl); REGISTER_MATCHER(containsDeclaration); REGISTER_MATCHER(continueStmt); REGISTER_MATCHER(ctorInitializer); REGISTER_MATCHER(decl); REGISTER_MATCHER(declCountIs); REGISTER_MATCHER(declRefExpr); REGISTER_MATCHER(declStmt); REGISTER_MATCHER(declaratorDecl); REGISTER_MATCHER(defaultArgExpr); REGISTER_MATCHER(defaultStmt); REGISTER_MATCHER(deleteExpr); REGISTER_MATCHER(dependentSizedArrayType); REGISTER_MATCHER(destructorDecl); REGISTER_MATCHER(doStmt); REGISTER_MATCHER(dynamicCastExpr); REGISTER_MATCHER(eachOf); REGISTER_MATCHER(elaboratedType); REGISTER_MATCHER(enumConstantDecl); REGISTER_MATCHER(enumDecl); REGISTER_MATCHER(equalsBoundNode); REGISTER_MATCHER(explicitCastExpr); REGISTER_MATCHER(expr); REGISTER_MATCHER(fieldDecl); REGISTER_MATCHER(floatLiteral); REGISTER_MATCHER(forEach); REGISTER_MATCHER(forEachConstructorInitializer); REGISTER_MATCHER(forEachDescendant); REGISTER_MATCHER(forEachSwitchCase); REGISTER_MATCHER(forField); REGISTER_MATCHER(forRangeStmt); REGISTER_MATCHER(forStmt); REGISTER_MATCHER(friendDecl); REGISTER_MATCHER(functionDecl); REGISTER_MATCHER(functionTemplateDecl); REGISTER_MATCHER(functionType); REGISTER_MATCHER(functionalCastExpr); REGISTER_MATCHER(gotoStmt); REGISTER_MATCHER(has); REGISTER_MATCHER(hasAncestor); REGISTER_MATCHER(hasAnyArgument); REGISTER_MATCHER(hasAnyConstructorInitializer); REGISTER_MATCHER(hasAnyParameter); REGISTER_MATCHER(hasAnySubstatement); REGISTER_MATCHER(hasAnyTemplateArgument); REGISTER_MATCHER(hasAnyUsingShadowDecl); REGISTER_MATCHER(hasArgument); REGISTER_MATCHER(hasArgumentOfType); REGISTER_MATCHER(hasBase); REGISTER_MATCHER(hasBody); REGISTER_MATCHER(hasCanonicalType); REGISTER_MATCHER(hasCaseConstant); REGISTER_MATCHER(hasCondition); REGISTER_MATCHER(hasConditionVariableStatement); REGISTER_MATCHER(hasDeclContext); REGISTER_MATCHER(hasDeclaration); REGISTER_MATCHER(hasDeducedType); REGISTER_MATCHER(hasDescendant); REGISTER_MATCHER(hasDestinationType); REGISTER_MATCHER(hasEitherOperand); REGISTER_MATCHER(hasElementType); REGISTER_MATCHER(hasFalseExpression); REGISTER_MATCHER(hasImplicitDestinationType); REGISTER_MATCHER(hasIncrement); REGISTER_MATCHER(hasIndex); REGISTER_MATCHER(hasInitializer); REGISTER_MATCHER(hasLHS); REGISTER_MATCHER(hasLocalQualifiers); REGISTER_MATCHER(hasLoopInit); REGISTER_MATCHER(hasMethod); REGISTER_MATCHER(hasName); REGISTER_MATCHER(hasObjectExpression); REGISTER_MATCHER(hasOperatorName); REGISTER_MATCHER(hasOverloadedOperatorName); REGISTER_MATCHER(hasParameter); REGISTER_MATCHER(hasParent); REGISTER_MATCHER(hasQualifier); REGISTER_MATCHER(hasRHS); REGISTER_MATCHER(hasSingleDecl); REGISTER_MATCHER(hasSize); REGISTER_MATCHER(hasSizeExpr); REGISTER_MATCHER(hasSourceExpression); REGISTER_MATCHER(hasTargetDecl); REGISTER_MATCHER(hasTemplateArgument); REGISTER_MATCHER(hasTrueExpression); REGISTER_MATCHER(hasTypeLoc); REGISTER_MATCHER(hasUnaryOperand); REGISTER_MATCHER(hasValueType); REGISTER_MATCHER(ifStmt); REGISTER_MATCHER(ignoringImpCasts); REGISTER_MATCHER(ignoringParenCasts); REGISTER_MATCHER(ignoringParenImpCasts); REGISTER_MATCHER(implicitCastExpr); REGISTER_MATCHER(incompleteArrayType); REGISTER_MATCHER(initListExpr); REGISTER_MATCHER(innerType); REGISTER_MATCHER(integerLiteral); REGISTER_MATCHER(isArrow); REGISTER_MATCHER(isConst); REGISTER_MATCHER(isConstQualified); REGISTER_MATCHER(isDefinition); REGISTER_MATCHER(isExplicitTemplateSpecialization); REGISTER_MATCHER(isExpr); REGISTER_MATCHER(isExternC); REGISTER_MATCHER(isImplicit); REGISTER_MATCHER(isInteger); REGISTER_MATCHER(isListInitialization); REGISTER_MATCHER(isOverride); REGISTER_MATCHER(isPrivate); REGISTER_MATCHER(isProtected); REGISTER_MATCHER(isPublic); REGISTER_MATCHER(isTemplateInstantiation); REGISTER_MATCHER(isVirtual); REGISTER_MATCHER(isWritten); REGISTER_MATCHER(lValueReferenceType); REGISTER_MATCHER(labelStmt); REGISTER_MATCHER(lambdaExpr); REGISTER_MATCHER(matchesName); REGISTER_MATCHER(materializeTemporaryExpr); REGISTER_MATCHER(member); REGISTER_MATCHER(memberCallExpr); REGISTER_MATCHER(memberExpr); REGISTER_MATCHER(memberPointerType); REGISTER_MATCHER(methodDecl); REGISTER_MATCHER(namedDecl); REGISTER_MATCHER(namesType); REGISTER_MATCHER(namespaceDecl); REGISTER_MATCHER(nestedNameSpecifier); REGISTER_MATCHER(nestedNameSpecifierLoc); REGISTER_MATCHER(newExpr); REGISTER_MATCHER(nullPtrLiteralExpr); REGISTER_MATCHER(nullStmt); REGISTER_MATCHER(ofClass); REGISTER_MATCHER(on); REGISTER_MATCHER(onImplicitObjectArgument); REGISTER_MATCHER(operatorCallExpr); REGISTER_MATCHER(parameterCountIs); REGISTER_MATCHER(parenType); REGISTER_MATCHER(parmVarDecl); REGISTER_MATCHER(pointee); REGISTER_MATCHER(pointerType); REGISTER_MATCHER(qualType); REGISTER_MATCHER(rValueReferenceType); REGISTER_MATCHER(recordDecl); REGISTER_MATCHER(recordType); REGISTER_MATCHER(referenceType); REGISTER_MATCHER(refersToDeclaration); REGISTER_MATCHER(refersToType); REGISTER_MATCHER(reinterpretCastExpr); REGISTER_MATCHER(returnStmt); REGISTER_MATCHER(returns); REGISTER_MATCHER(sizeOfExpr); REGISTER_MATCHER(specifiesNamespace); REGISTER_MATCHER(specifiesType); REGISTER_MATCHER(specifiesTypeLoc); REGISTER_MATCHER(statementCountIs); REGISTER_MATCHER(staticCastExpr); REGISTER_MATCHER(stmt); REGISTER_MATCHER(stringLiteral); REGISTER_MATCHER(switchCase); REGISTER_MATCHER(switchStmt); REGISTER_MATCHER(templateSpecializationType); REGISTER_MATCHER(temporaryObjectExpr); REGISTER_MATCHER(thisExpr); REGISTER_MATCHER(throughUsingDecl); REGISTER_MATCHER(throwExpr); REGISTER_MATCHER(to); REGISTER_MATCHER(tryStmt); REGISTER_MATCHER(type); REGISTER_MATCHER(typeLoc); REGISTER_MATCHER(typedefType); REGISTER_MATCHER(unaryExprOrTypeTraitExpr); REGISTER_MATCHER(unaryOperator); REGISTER_MATCHER(unaryTransformType); REGISTER_MATCHER(unless); REGISTER_MATCHER(unresolvedConstructExpr); REGISTER_MATCHER(unresolvedUsingValueDecl); REGISTER_MATCHER(userDefinedLiteral); REGISTER_MATCHER(usingDecl); REGISTER_MATCHER(varDecl); REGISTER_MATCHER(variableArrayType); REGISTER_MATCHER(whileStmt); REGISTER_MATCHER(withInitializer); } RegistryMaps::~RegistryMaps() { for (ConstructorMap::iterator it = Constructors.begin(), end = Constructors.end(); it != end; ++it) { delete it->second; } } static llvm::ManagedStatic RegistryData; } // anonymous namespace // static llvm::Optional Registry::lookupMatcherCtor(StringRef MatcherName, const SourceRange &NameRange, Diagnostics *Error) { ConstructorMap::const_iterator it = RegistryData->constructors().find(MatcherName); if (it == RegistryData->constructors().end()) { Error->addError(NameRange, Error->ET_RegistryNotFound) << MatcherName; return llvm::Optional(); } return it->second; } namespace { llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const std::set &KS) { unsigned Count = 0; for (std::set::const_iterator I = KS.begin(), E = KS.end(); I != E; ++I) { if (I != KS.begin()) OS << "|"; if (Count++ == 3) { OS << "..."; break; } OS << *I; } return OS; } struct ReverseSpecificityThenName { bool operator()(const std::pair &A, const std::pair &B) const { return A.first > B.first || (A.first == B.first && A.second < B.second); } }; } std::vector Registry::getCompletions( llvm::ArrayRef > Context) { ASTNodeKind InitialTypes[] = { ASTNodeKind::getFromNodeKind(), ASTNodeKind::getFromNodeKind(), ASTNodeKind::getFromNodeKind(), ASTNodeKind::getFromNodeKind(), ASTNodeKind::getFromNodeKind(), ASTNodeKind::getFromNodeKind(), ASTNodeKind::getFromNodeKind() }; llvm::ArrayRef InitialTypesRef(InitialTypes); // Starting with the above seed of acceptable top-level matcher types, compute // the acceptable type set for the argument indicated by each context element. std::set TypeSet(InitialTypesRef.begin(), InitialTypesRef.end()); for (llvm::ArrayRef >::iterator CtxI = Context.begin(), CtxE = Context.end(); CtxI != CtxE; ++CtxI) { std::vector NextTypeSet; for (std::set::iterator I = TypeSet.begin(), E = TypeSet.end(); I != E; ++I) { if (CtxI->first->isConvertibleTo(*I) && (CtxI->first->isVariadic() || CtxI->second < CtxI->first->getNumArgs())) CtxI->first->getArgKinds(*I, CtxI->second, NextTypeSet); } TypeSet.clear(); for (std::vector::iterator I = NextTypeSet.begin(), E = NextTypeSet.end(); I != E; ++I) { if (I->getArgKind() == internal::ArgKind::AK_Matcher) TypeSet.insert(I->getMatcherKind()); } } typedef std::map, MatcherCompletion, ReverseSpecificityThenName> CompletionsTy; CompletionsTy Completions; // TypeSet now contains the list of acceptable types for the argument we are // completing. Search the registry for acceptable matchers. for (ConstructorMap::const_iterator I = RegistryData->constructors().begin(), E = RegistryData->constructors().end(); I != E; ++I) { std::set RetKinds; unsigned NumArgs = I->second->isVariadic() ? 1 : I->second->getNumArgs(); bool IsPolymorphic = I->second->isPolymorphic(); std::vector > ArgsKinds(NumArgs); unsigned MaxSpecificity = 0; for (std::set::iterator TI = TypeSet.begin(), TE = TypeSet.end(); TI != TE; ++TI) { unsigned Specificity; ASTNodeKind LeastDerivedKind; if (I->second->isConvertibleTo(*TI, &Specificity, &LeastDerivedKind)) { if (MaxSpecificity < Specificity) MaxSpecificity = Specificity; RetKinds.insert(LeastDerivedKind); for (unsigned Arg = 0; Arg != NumArgs; ++Arg) I->second->getArgKinds(*TI, Arg, ArgsKinds[Arg]); if (IsPolymorphic) break; } } if (!RetKinds.empty() && MaxSpecificity > 0) { std::string Decl; llvm::raw_string_ostream OS(Decl); if (IsPolymorphic) { OS << "Matcher " << I->first() << "(Matcher"; } else { OS << "Matcher<" << RetKinds << "> " << I->first() << "("; for (std::vector >::iterator KI = ArgsKinds.begin(), KE = ArgsKinds.end(); KI != KE; ++KI) { if (KI != ArgsKinds.begin()) OS << ", "; // This currently assumes that a matcher may not overload a // non-matcher, and all non-matcher overloads have identical // arguments. if ((*KI)[0].getArgKind() == internal::ArgKind::AK_Matcher) { std::set MatcherKinds; std::transform( KI->begin(), KI->end(), std::inserter(MatcherKinds, MatcherKinds.end()), std::mem_fun_ref(&internal::ArgKind::getMatcherKind)); OS << "Matcher<" << MatcherKinds << ">"; } else { OS << (*KI)[0].asString(); } } } if (I->second->isVariadic()) OS << "..."; OS << ")"; std::string TypedText = I->first(); TypedText += "("; if (ArgsKinds.empty()) TypedText += ")"; else if (ArgsKinds[0][0].getArgKind() == internal::ArgKind::AK_String) TypedText += "\""; Completions[std::make_pair(MaxSpecificity, I->first())] = MatcherCompletion(TypedText, OS.str()); } } std::vector RetVal; for (CompletionsTy::iterator I = Completions.begin(), E = Completions.end(); I != E; ++I) RetVal.push_back(I->second); return RetVal; } // static VariantMatcher Registry::constructMatcher(MatcherCtor Ctor, const SourceRange &NameRange, ArrayRef Args, Diagnostics *Error) { return Ctor->create(NameRange, Args, Error); } // static VariantMatcher Registry::constructBoundMatcher(MatcherCtor Ctor, const SourceRange &NameRange, StringRef BindID, ArrayRef Args, Diagnostics *Error) { VariantMatcher Out = constructMatcher(Ctor, NameRange, Args, Error); if (Out.isNull()) return Out; llvm::Optional Result = Out.getSingleMatcher(); if (Result.hasValue()) { llvm::Optional Bound = Result->tryBind(BindID); if (Bound.hasValue()) { return VariantMatcher::SingleMatcher(*Bound); } } Error->addError(NameRange, Error->ET_RegistryNotBindable); return VariantMatcher(); } } // namespace dynamic } // namespace ast_matchers } // namespace clang @