diff options
Diffstat (limited to 'lib/ASTMatchers')
| -rw-r--r-- | lib/ASTMatchers/ASTMatchFinder.cpp | 27 | ||||
| -rw-r--r-- | lib/ASTMatchers/ASTMatchersInternal.cpp | 22 | ||||
| -rw-r--r-- | lib/ASTMatchers/Dynamic/Parser.cpp | 106 | ||||
| -rw-r--r-- | lib/ASTMatchers/Dynamic/Registry.cpp | 47 |
4 files changed, 139 insertions, 63 deletions
diff --git a/lib/ASTMatchers/ASTMatchFinder.cpp b/lib/ASTMatchers/ASTMatchFinder.cpp index 63f8395b8277..dec2e2ad1f93 100644 --- a/lib/ASTMatchers/ASTMatchFinder.cpp +++ b/lib/ASTMatchers/ASTMatchFinder.cpp @@ -635,10 +635,6 @@ private: bool memoizedMatchesAncestorOfRecursively( const ast_type_traits::DynTypedNode &Node, const DynTypedMatcher &Matcher, BoundNodesTreeBuilder *Builder, AncestorMatchMode MatchMode) { - if (Node.get<TranslationUnitDecl>() == - ActiveASTContext->getTranslationUnitDecl()) - return false; - // For AST-nodes that don't have an identity, we can't memoize. if (!Builder->isComparable()) return matchesAncestorOfRecursively(Node, Matcher, Builder, MatchMode); @@ -673,7 +669,26 @@ private: BoundNodesTreeBuilder *Builder, AncestorMatchMode MatchMode) { const auto &Parents = ActiveASTContext->getParents(Node); - assert(!Parents.empty() && "Found node that is not in the parent map."); + if (Parents.empty()) { + // Nodes may have no parents if: + // a) the node is the TranslationUnitDecl + // b) we have a limited traversal scope that excludes the parent edges + // c) there is a bug in the AST, and the node is not reachable + // Usually the traversal scope is the whole AST, which precludes b. + // Bugs are common enough that it's worthwhile asserting when we can. +#ifndef NDEBUG + if (!Node.get<TranslationUnitDecl>() && + /* Traversal scope is full AST if any of the bounds are the TU */ + llvm::any_of(ActiveASTContext->getTraversalScope(), [](Decl *D) { + return D->getKind() == Decl::TranslationUnit; + })) { + llvm::errs() << "Tried to match orphan node:\n"; + Node.dump(llvm::errs(), ActiveASTContext->getSourceManager()); + llvm_unreachable("Parent map should be complete!"); + } +#endif + return false; + } if (Parents.size() == 1) { // Only one parent - do recursive memoization. const ast_type_traits::DynTypedNode Parent = Parents[0]; @@ -1019,7 +1034,7 @@ void MatchFinder::matchAST(ASTContext &Context) { internal::MatchASTVisitor Visitor(&Matchers, Options); Visitor.set_active_ast_context(&Context); Visitor.onStartOfTranslationUnit(); - Visitor.TraverseDecl(Context.getTranslationUnitDecl()); + Visitor.TraverseAST(Context); Visitor.onEndOfTranslationUnit(); } diff --git a/lib/ASTMatchers/ASTMatchersInternal.cpp b/lib/ASTMatchers/ASTMatchersInternal.cpp index 9cea2f5efc5b..e1aae172a8d6 100644 --- a/lib/ASTMatchers/ASTMatchersInternal.cpp +++ b/lib/ASTMatchers/ASTMatchersInternal.cpp @@ -144,10 +144,10 @@ DynTypedMatcher DynTypedMatcher::constructVariadic( ast_type_traits::ASTNodeKind SupportedKind, std::vector<DynTypedMatcher> InnerMatchers) { assert(!InnerMatchers.empty() && "Array must not be empty."); - assert(std::all_of(InnerMatchers.begin(), InnerMatchers.end(), - [SupportedKind](const DynTypedMatcher &M) { - return M.canConvertTo(SupportedKind); - }) && + assert(llvm::all_of(InnerMatchers, + [SupportedKind](const DynTypedMatcher &M) { + return M.canConvertTo(SupportedKind); + }) && "InnerMatchers must be convertible to SupportedKind!"); // We must relax the restrict kind here. @@ -449,7 +449,7 @@ bool HasNameMatcher::matchesNodeUnqualified(const NamedDecl &Node) const { assert(UseUnqualifiedMatch); llvm::SmallString<128> Scratch; StringRef NodeName = getNodeName(Node, Scratch); - return std::any_of(Names.begin(), Names.end(), [&](StringRef Name) { + return llvm::any_of(Names, [&](StringRef Name) { return consumeNameSuffix(Name, NodeName) && Name.empty(); }); } @@ -573,6 +573,9 @@ const internal::VariadicDynCastAllOfMatcher<Decl, ClassTemplateDecl> const internal::VariadicDynCastAllOfMatcher<Decl, ClassTemplateSpecializationDecl> classTemplateSpecializationDecl; +const internal::VariadicDynCastAllOfMatcher< + Decl, ClassTemplatePartialSpecializationDecl> + classTemplatePartialSpecializationDecl; const internal::VariadicDynCastAllOfMatcher<Decl, DeclaratorDecl> declaratorDecl; const internal::VariadicDynCastAllOfMatcher<Decl, ParmVarDecl> parmVarDecl; @@ -603,6 +606,8 @@ const internal::VariadicDynCastAllOfMatcher<Decl, CXXConversionDecl> cxxConversionDecl; const internal::VariadicDynCastAllOfMatcher<Decl, VarDecl> varDecl; const internal::VariadicDynCastAllOfMatcher<Decl, FieldDecl> fieldDecl; +const internal::VariadicDynCastAllOfMatcher<Decl, IndirectFieldDecl> + indirectFieldDecl; const internal::VariadicDynCastAllOfMatcher<Decl, FunctionDecl> functionDecl; const internal::VariadicDynCastAllOfMatcher<Decl, FunctionTemplateDecl> functionTemplateDecl; @@ -610,6 +615,10 @@ const internal::VariadicDynCastAllOfMatcher<Decl, FriendDecl> friendDecl; const internal::VariadicAllOfMatcher<Stmt> stmt; const internal::VariadicDynCastAllOfMatcher<Stmt, DeclStmt> declStmt; const internal::VariadicDynCastAllOfMatcher<Stmt, MemberExpr> memberExpr; +const internal::VariadicDynCastAllOfMatcher<Stmt, UnresolvedMemberExpr> + unresolvedMemberExpr; +const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDependentScopeMemberExpr> + cxxDependentScopeMemberExpr; const internal::VariadicDynCastAllOfMatcher<Stmt, CallExpr> callExpr; const internal::VariadicDynCastAllOfMatcher<Stmt, LambdaExpr> lambdaExpr; const internal::VariadicDynCastAllOfMatcher<Stmt, CXXMemberCallExpr> @@ -659,6 +668,7 @@ const internal::VariadicDynCastAllOfMatcher<Decl, UnresolvedUsingValueDecl> unresolvedUsingValueDecl; const internal::VariadicDynCastAllOfMatcher<Decl, UnresolvedUsingTypenameDecl> unresolvedUsingTypenameDecl; +const internal::VariadicDynCastAllOfMatcher<Stmt, ConstantExpr> constantExpr; const internal::VariadicDynCastAllOfMatcher<Stmt, ParenExpr> parenExpr; const internal::VariadicDynCastAllOfMatcher<Stmt, CXXConstructExpr> cxxConstructExpr; @@ -680,6 +690,7 @@ const internal::VariadicDynCastAllOfMatcher<Stmt, CXXOperatorCallExpr> const internal::VariadicDynCastAllOfMatcher<Stmt, Expr> expr; const internal::VariadicDynCastAllOfMatcher<Stmt, DeclRefExpr> declRefExpr; const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCIvarRefExpr> objcIvarRefExpr; +const internal::VariadicDynCastAllOfMatcher<Stmt, BlockExpr> blockExpr; const internal::VariadicDynCastAllOfMatcher<Stmt, IfStmt> ifStmt; const internal::VariadicDynCastAllOfMatcher<Stmt, ForStmt> forStmt; const internal::VariadicDynCastAllOfMatcher<Stmt, CXXForRangeStmt> @@ -710,6 +721,7 @@ const internal::VariadicDynCastAllOfMatcher<Stmt, CharacterLiteral> const internal::VariadicDynCastAllOfMatcher<Stmt, IntegerLiteral> integerLiteral; const internal::VariadicDynCastAllOfMatcher<Stmt, FloatingLiteral> floatLiteral; +const internal::VariadicDynCastAllOfMatcher<Stmt, ImaginaryLiteral> imaginaryLiteral; const internal::VariadicDynCastAllOfMatcher<Stmt, UserDefinedLiteral> userDefinedLiteral; const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundLiteralExpr> diff --git a/lib/ASTMatchers/Dynamic/Parser.cpp b/lib/ASTMatchers/Dynamic/Parser.cpp index da8df907ba7f..5db10048fdf8 100644 --- a/lib/ASTMatchers/Dynamic/Parser.cpp +++ b/lib/ASTMatchers/Dynamic/Parser.cpp @@ -110,6 +110,10 @@ private: } switch (Code[0]) { + case '#': + Result.Kind = TokenInfo::TK_Eof; + Result.Text = ""; + return Result; case ',': Result.Kind = TokenInfo::TK_Comma; Result.Text = Code.substr(0, 1); @@ -339,8 +343,27 @@ bool Parser::parseIdentifierPrefixImpl(VariantValue *Value) { if (const VariantValue NamedValue = NamedValues ? NamedValues->lookup(NameToken.Text) : VariantValue()) { - *Value = NamedValue; - return true; + + if (Tokenizer->nextTokenKind() != TokenInfo::TK_Period) { + *Value = NamedValue; + return true; + } + + std::string BindID; + if (!parseBindID(BindID)) + return false; + + assert(NamedValue.isMatcher()); + llvm::Optional<DynTypedMatcher> Result = + NamedValue.getMatcher().getSingleMatcher(); + if (Result.hasValue()) { + llvm::Optional<DynTypedMatcher> Bound = Result->tryBind(BindID); + if (Bound.hasValue()) { + *Value = VariantMatcher::SingleMatcher(*Bound); + return true; + } + } + return false; } // If the syntax is correct and the name is not a matcher either, report // unknown named value. @@ -359,6 +382,43 @@ bool Parser::parseIdentifierPrefixImpl(VariantValue *Value) { return parseMatcherExpressionImpl(NameToken, Value); } +bool Parser::parseBindID(std::string &BindID) { + // Parse .bind("foo") + assert(Tokenizer->peekNextToken().Kind == TokenInfo::TK_Period); + Tokenizer->consumeNextToken(); // consume the period. + const TokenInfo BindToken = Tokenizer->consumeNextToken(); + if (BindToken.Kind == TokenInfo::TK_CodeCompletion) { + addCompletion(BindToken, MatcherCompletion("bind(\"", "bind", 1)); + return false; + } + + const TokenInfo OpenToken = Tokenizer->consumeNextToken(); + const TokenInfo IDToken = Tokenizer->consumeNextToken(); + const TokenInfo CloseToken = Tokenizer->consumeNextToken(); + + // TODO: We could use different error codes for each/some to be more + // explicit about the syntax error. + if (BindToken.Kind != TokenInfo::TK_Ident || + BindToken.Text != TokenInfo::ID_Bind) { + Error->addError(BindToken.Range, Error->ET_ParserMalformedBindExpr); + return false; + } + if (OpenToken.Kind != TokenInfo::TK_OpenParen) { + Error->addError(OpenToken.Range, Error->ET_ParserMalformedBindExpr); + return false; + } + if (IDToken.Kind != TokenInfo::TK_Literal || !IDToken.Value.isString()) { + Error->addError(IDToken.Range, Error->ET_ParserMalformedBindExpr); + return false; + } + if (CloseToken.Kind != TokenInfo::TK_CloseParen) { + Error->addError(CloseToken.Range, Error->ET_ParserMalformedBindExpr); + return false; + } + BindID = IDToken.Value.getString(); + return true; +} + /// Parse and validate a matcher expression. /// \return \c true on success, in which case \c Value has the matcher parsed. /// If the input is malformed, or some argument has an error, it @@ -425,38 +485,8 @@ bool Parser::parseMatcherExpressionImpl(const TokenInfo &NameToken, std::string BindID; if (Tokenizer->peekNextToken().Kind == TokenInfo::TK_Period) { - // Parse .bind("foo") - Tokenizer->consumeNextToken(); // consume the period. - const TokenInfo BindToken = Tokenizer->consumeNextToken(); - if (BindToken.Kind == TokenInfo::TK_CodeCompletion) { - addCompletion(BindToken, MatcherCompletion("bind(\"", "bind", 1)); + if (!parseBindID(BindID)) return false; - } - - const TokenInfo OpenToken = Tokenizer->consumeNextToken(); - const TokenInfo IDToken = Tokenizer->consumeNextToken(); - const TokenInfo CloseToken = Tokenizer->consumeNextToken(); - - // TODO: We could use different error codes for each/some to be more - // explicit about the syntax error. - if (BindToken.Kind != TokenInfo::TK_Ident || - BindToken.Text != TokenInfo::ID_Bind) { - Error->addError(BindToken.Range, Error->ET_ParserMalformedBindExpr); - return false; - } - if (OpenToken.Kind != TokenInfo::TK_OpenParen) { - Error->addError(OpenToken.Range, Error->ET_ParserMalformedBindExpr); - return false; - } - if (IDToken.Kind != TokenInfo::TK_Literal || !IDToken.Value.isString()) { - Error->addError(IDToken.Range, Error->ET_ParserMalformedBindExpr); - return false; - } - if (CloseToken.Kind != TokenInfo::TK_CloseParen) { - Error->addError(CloseToken.Range, Error->ET_ParserMalformedBindExpr); - return false; - } - BindID = IDToken.Value.getString(); } if (!Ctor) @@ -619,12 +649,12 @@ Parser::completeExpression(StringRef Code, unsigned CompletionOffset, Sema *S, P.parseExpressionImpl(&Dummy); // Sort by specificity, then by name. - llvm::sort(P.Completions.begin(), P.Completions.end(), + llvm::sort(P.Completions, [](const MatcherCompletion &A, const MatcherCompletion &B) { - if (A.Specificity != B.Specificity) - return A.Specificity > B.Specificity; - return A.TypedText < B.TypedText; - }); + if (A.Specificity != B.Specificity) + return A.Specificity > B.Specificity; + return A.TypedText < B.TypedText; + }); return P.Completions; } diff --git a/lib/ASTMatchers/Dynamic/Registry.cpp b/lib/ASTMatchers/Dynamic/Registry.cpp index 4d2d76f6a75b..e6e48467967e 100644 --- a/lib/ASTMatchers/Dynamic/Registry.cpp +++ b/lib/ASTMatchers/Dynamic/Registry.cpp @@ -106,6 +106,7 @@ RegistryMaps::RegistryMaps() { REGISTER_OVERLOADED_2(callee); REGISTER_OVERLOADED_2(hasPrefix); REGISTER_OVERLOADED_2(hasType); + REGISTER_OVERLOADED_2(ignoringParens); REGISTER_OVERLOADED_2(isDerivedFrom); REGISTER_OVERLOADED_2(isSameOrDerivedFrom); REGISTER_OVERLOADED_2(loc); @@ -133,11 +134,12 @@ RegistryMaps::RegistryMaps() { REGISTER_MATCHER(asString); REGISTER_MATCHER(atomicExpr); REGISTER_MATCHER(atomicType); - REGISTER_MATCHER(autoType); REGISTER_MATCHER(autoreleasePoolStmt) - REGISTER_MATCHER(binaryOperator); + REGISTER_MATCHER(autoType); REGISTER_MATCHER(binaryConditionalOperator); + REGISTER_MATCHER(binaryOperator); REGISTER_MATCHER(blockDecl); + REGISTER_MATCHER(blockExpr); REGISTER_MATCHER(blockPointerType); REGISTER_MATCHER(booleanType); REGISTER_MATCHER(breakStmt); @@ -153,6 +155,7 @@ RegistryMaps::RegistryMaps() { REGISTER_MATCHER(compoundStmt); REGISTER_MATCHER(conditionalOperator); REGISTER_MATCHER(constantArrayType); + REGISTER_MATCHER(constantExpr); REGISTER_MATCHER(containsDeclaration); REGISTER_MATCHER(continueStmt); REGISTER_MATCHER(cStyleCastExpr); @@ -167,6 +170,7 @@ RegistryMaps::RegistryMaps() { REGISTER_MATCHER(cxxCtorInitializer); REGISTER_MATCHER(cxxDefaultArgExpr); REGISTER_MATCHER(cxxDeleteExpr); + REGISTER_MATCHER(cxxDependentScopeMemberExpr); REGISTER_MATCHER(cxxDestructorDecl); REGISTER_MATCHER(cxxDynamicCastExpr); REGISTER_MATCHER(cxxForRangeStmt); @@ -188,10 +192,10 @@ RegistryMaps::RegistryMaps() { REGISTER_MATCHER(decayedType); REGISTER_MATCHER(decl); REGISTER_MATCHER(declaratorDecl); - REGISTER_MATCHER(decltypeType); REGISTER_MATCHER(declCountIs); REGISTER_MATCHER(declRefExpr); REGISTER_MATCHER(declStmt); + REGISTER_MATCHER(decltypeType); REGISTER_MATCHER(defaultStmt); REGISTER_MATCHER(dependentSizedArrayType); REGISTER_MATCHER(designatedInitExpr); @@ -208,6 +212,7 @@ RegistryMaps::RegistryMaps() { REGISTER_MATCHER(expr); REGISTER_MATCHER(exprWithCleanups); REGISTER_MATCHER(fieldDecl); + REGISTER_MATCHER(indirectFieldDecl); REGISTER_MATCHER(floatLiteral); REGISTER_MATCHER(forEach); REGISTER_MATCHER(forEachArgumentWithParam); @@ -232,6 +237,7 @@ RegistryMaps::RegistryMaps() { REGISTER_MATCHER(hasAnyDeclaration); REGISTER_MATCHER(hasAnyName); REGISTER_MATCHER(hasAnyParameter); + REGISTER_MATCHER(hasAnySelector); REGISTER_MATCHER(hasAnySubstatement); REGISTER_MATCHER(hasAnyTemplateArgument); REGISTER_MATCHER(hasAnyUsingShadowDecl); @@ -267,6 +273,7 @@ RegistryMaps::RegistryMaps() { REGISTER_MATCHER(hasInClassInitializer); REGISTER_MATCHER(hasIncrement); REGISTER_MATCHER(hasIndex); + REGISTER_MATCHER(hasInit); REGISTER_MATCHER(hasInitializer); REGISTER_MATCHER(hasKeywordSelector); REGISTER_MATCHER(hasLHS); @@ -290,11 +297,11 @@ RegistryMaps::RegistryMaps() { REGISTER_MATCHER(hasReturnValue); REGISTER_MATCHER(hasRHS); REGISTER_MATCHER(hasSelector); - REGISTER_MATCHER(hasAnySelector); REGISTER_MATCHER(hasSingleDecl); REGISTER_MATCHER(hasSize); REGISTER_MATCHER(hasSizeExpr); REGISTER_MATCHER(hasSourceExpression); + REGISTER_MATCHER(hasSpecializedTemplate); REGISTER_MATCHER(hasStaticStorageDuration); REGISTER_MATCHER(hasSyntacticForm); REGISTER_MATCHER(hasTargetDecl); @@ -307,14 +314,15 @@ RegistryMaps::RegistryMaps() { REGISTER_MATCHER(hasUnaryOperand); REGISTER_MATCHER(hasUnarySelector); REGISTER_MATCHER(hasUnderlyingDecl); + REGISTER_MATCHER(hasUnderlyingType); REGISTER_MATCHER(hasUnqualifiedDesugaredType); REGISTER_MATCHER(hasValueType); REGISTER_MATCHER(ifStmt); - REGISTER_MATCHER(ignoringImplicit); REGISTER_MATCHER(ignoringImpCasts); + REGISTER_MATCHER(ignoringImplicit); REGISTER_MATCHER(ignoringParenCasts); REGISTER_MATCHER(ignoringParenImpCasts); - REGISTER_MATCHER(ignoringParens); + REGISTER_MATCHER(imaginaryLiteral); REGISTER_MATCHER(implicitCastExpr); REGISTER_MATCHER(implicitValueInitExpr); REGISTER_MATCHER(incompleteArrayType); @@ -341,19 +349,21 @@ RegistryMaps::RegistryMaps() { REGISTER_MATCHER(isDefaulted); REGISTER_MATCHER(isDefinition); REGISTER_MATCHER(isDeleted); + REGISTER_MATCHER(isDelegatingConstructor); REGISTER_MATCHER(isExceptionVariable); + REGISTER_MATCHER(isExpansionInFileMatching); + REGISTER_MATCHER(isExpansionInMainFile); + REGISTER_MATCHER(isExpansionInSystemHeader); REGISTER_MATCHER(isExplicit); REGISTER_MATCHER(isExplicitTemplateSpecialization); REGISTER_MATCHER(isExpr); REGISTER_MATCHER(isExternC); REGISTER_MATCHER(isFinal); - REGISTER_MATCHER(isInline); REGISTER_MATCHER(isImplicit); - REGISTER_MATCHER(isExpansionInFileMatching); - REGISTER_MATCHER(isExpansionInMainFile); + REGISTER_MATCHER(isInline); REGISTER_MATCHER(isInstanceMessage); REGISTER_MATCHER(isInstantiated); - REGISTER_MATCHER(isExpansionInSystemHeader); + REGISTER_MATCHER(isInstantiationDependent); REGISTER_MATCHER(isInteger); REGISTER_MATCHER(isIntegral); REGISTER_MATCHER(isInTemplateInstantiation); @@ -372,11 +382,15 @@ RegistryMaps::RegistryMaps() { REGISTER_MATCHER(isPure); REGISTER_MATCHER(isScoped); REGISTER_MATCHER(isSignedInteger); + REGISTER_MATCHER(isStaticLocal); REGISTER_MATCHER(isStaticStorageClass); REGISTER_MATCHER(isStruct); REGISTER_MATCHER(isTemplateInstantiation); + REGISTER_MATCHER(isTypeDependent); REGISTER_MATCHER(isUnion); REGISTER_MATCHER(isUnsignedInteger); + REGISTER_MATCHER(isUserProvided); + REGISTER_MATCHER(isValueDependent); REGISTER_MATCHER(isVariadic); REGISTER_MATCHER(isVirtual); REGISTER_MATCHER(isVirtualAsWritten); @@ -399,10 +413,10 @@ RegistryMaps::RegistryMaps() { REGISTER_MATCHER(namesType); REGISTER_MATCHER(nestedNameSpecifier); REGISTER_MATCHER(nestedNameSpecifierLoc); + REGISTER_MATCHER(nonTypeTemplateParmDecl); REGISTER_MATCHER(nullPointerConstant); REGISTER_MATCHER(nullStmt); REGISTER_MATCHER(numSelectorArgs); - REGISTER_MATCHER(ofClass); REGISTER_MATCHER(objcCatchStmt); REGISTER_MATCHER(objcCategoryDecl); REGISTER_MATCHER(objcCategoryImplDecl); @@ -418,6 +432,7 @@ RegistryMaps::RegistryMaps() { REGISTER_MATCHER(objcProtocolDecl); REGISTER_MATCHER(objcThrowStmt); REGISTER_MATCHER(objcTryStmt); + REGISTER_MATCHER(ofClass); REGISTER_MATCHER(on); REGISTER_MATCHER(onImplicitObjectArgument); REGISTER_MATCHER(opaqueValueExpr); @@ -437,6 +452,7 @@ RegistryMaps::RegistryMaps() { REGISTER_MATCHER(refersToDeclaration); REGISTER_MATCHER(refersToIntegralType); REGISTER_MATCHER(refersToType); + REGISTER_MATCHER(refersToTemplate); REGISTER_MATCHER(requiresZeroInitialization); REGISTER_MATCHER(returns); REGISTER_MATCHER(returnStmt); @@ -454,9 +470,10 @@ RegistryMaps::RegistryMaps() { REGISTER_MATCHER(substTemplateTypeParmType); REGISTER_MATCHER(switchCase); REGISTER_MATCHER(switchStmt); + REGISTER_MATCHER(tagType); REGISTER_MATCHER(templateArgument); - REGISTER_MATCHER(templateName); REGISTER_MATCHER(templateArgumentCountIs); + REGISTER_MATCHER(templateName); REGISTER_MATCHER(templateSpecializationType); REGISTER_MATCHER(templateTypeParmDecl); REGISTER_MATCHER(templateTypeParmType); @@ -464,20 +481,22 @@ RegistryMaps::RegistryMaps() { REGISTER_MATCHER(to); REGISTER_MATCHER(translationUnitDecl); REGISTER_MATCHER(type); + REGISTER_MATCHER(typeAliasDecl); + REGISTER_MATCHER(typeAliasTemplateDecl); REGISTER_MATCHER(typedefDecl); REGISTER_MATCHER(typedefNameDecl); REGISTER_MATCHER(typedefType); - REGISTER_MATCHER(typeAliasDecl); - REGISTER_MATCHER(typeAliasTemplateDecl); REGISTER_MATCHER(typeLoc); REGISTER_MATCHER(unaryExprOrTypeTraitExpr); REGISTER_MATCHER(unaryOperator); REGISTER_MATCHER(unaryTransformType); REGISTER_MATCHER(unless); REGISTER_MATCHER(unresolvedLookupExpr); + REGISTER_MATCHER(unresolvedMemberExpr); REGISTER_MATCHER(unresolvedUsingTypenameDecl); REGISTER_MATCHER(unresolvedUsingValueDecl); REGISTER_MATCHER(userDefinedLiteral); + REGISTER_MATCHER(usesADL); REGISTER_MATCHER(usingDecl); REGISTER_MATCHER(usingDirectiveDecl); REGISTER_MATCHER(valueDecl); |