head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC5:1.1.1.7 netbsd-11-0-RC4:1.1.1.7 netbsd-11-0-RC3:1.1.1.7 netbsd-11-0-RC2:1.1.1.7 netbsd-11-0-RC1:1.1.1.7 perseant-exfatfs-base-20250801:1.1.1.7 netbsd-11:1.1.1.7.0.10 netbsd-11-base:1.1.1.7 netbsd-10-1-RELEASE:1.1.1.7 perseant-exfatfs-base-20240630:1.1.1.7 perseant-exfatfs:1.1.1.7.0.8 perseant-exfatfs-base:1.1.1.7 netbsd-8-3-RELEASE:1.1.1.5 netbsd-9-4-RELEASE:1.1.1.6 netbsd-10-0-RELEASE:1.1.1.7 netbsd-10-0-RC6:1.1.1.7 netbsd-10-0-RC5:1.1.1.7 netbsd-10-0-RC4:1.1.1.7 netbsd-10-0-RC3:1.1.1.7 netbsd-10-0-RC2:1.1.1.7 netbsd-10-0-RC1:1.1.1.7 netbsd-10:1.1.1.7.0.6 netbsd-10-base:1.1.1.7 netbsd-9-3-RELEASE:1.1.1.6 cjep_sun2x:1.1.1.7.0.4 cjep_sun2x-base:1.1.1.7 cjep_staticlib_x-base1:1.1.1.7 netbsd-9-2-RELEASE:1.1.1.6 cjep_staticlib_x:1.1.1.7.0.2 cjep_staticlib_x-base:1.1.1.7 netbsd-9-1-RELEASE:1.1.1.6 phil-wifi-20200421:1.1.1.7 phil-wifi-20200411:1.1.1.7 phil-wifi-20200406:1.1.1.7 netbsd-8-2-RELEASE:1.1.1.5 netbsd-9-0-RELEASE:1.1.1.6 netbsd-9-0-RC2:1.1.1.6 netbsd-9-0-RC1:1.1.1.6 netbsd-9:1.1.1.6.0.2 netbsd-9-base:1.1.1.6 phil-wifi-20190609:1.1.1.6 netbsd-8-1-RELEASE:1.1.1.5 netbsd-8-1-RC1:1.1.1.5 pgoyette-compat-merge-20190127:1.1.1.5.12.1 pgoyette-compat-20190127:1.1.1.6 pgoyette-compat-20190118:1.1.1.6 pgoyette-compat-1226:1.1.1.6 pgoyette-compat-1126:1.1.1.6 pgoyette-compat-1020:1.1.1.6 pgoyette-compat-0930:1.1.1.6 pgoyette-compat-0906:1.1.1.6 netbsd-7-2-RELEASE:1.1.1.2.6.1 pgoyette-compat-0728:1.1.1.6 clang-337282:1.1.1.6 netbsd-8-0-RELEASE:1.1.1.5 phil-wifi:1.1.1.5.0.14 phil-wifi-base:1.1.1.5 pgoyette-compat-0625:1.1.1.5 netbsd-8-0-RC2:1.1.1.5 pgoyette-compat-0521:1.1.1.5 pgoyette-compat-0502:1.1.1.5 pgoyette-compat-0422:1.1.1.5 netbsd-8-0-RC1:1.1.1.5 pgoyette-compat-0415:1.1.1.5 pgoyette-compat-0407:1.1.1.5 pgoyette-compat-0330:1.1.1.5 pgoyette-compat-0322:1.1.1.5 pgoyette-compat-0315:1.1.1.5 netbsd-7-1-2-RELEASE:1.1.1.2.6.1 pgoyette-compat:1.1.1.5.0.12 pgoyette-compat-base:1.1.1.5 netbsd-7-1-1-RELEASE:1.1.1.2.6.1 clang-319952:1.1.1.5 matt-nb8-mediatek:1.1.1.5.0.10 matt-nb8-mediatek-base:1.1.1.5 clang-309604:1.1.1.5 perseant-stdc-iso10646:1.1.1.5.0.8 perseant-stdc-iso10646-base:1.1.1.5 netbsd-8:1.1.1.5.0.6 netbsd-8-base:1.1.1.5 prg-localcount2-base3:1.1.1.5 prg-localcount2-base2:1.1.1.5 prg-localcount2-base1:1.1.1.5 prg-localcount2:1.1.1.5.0.4 prg-localcount2-base:1.1.1.5 pgoyette-localcount-20170426:1.1.1.5 bouyer-socketcan-base1:1.1.1.5 pgoyette-localcount-20170320:1.1.1.5 netbsd-7-1:1.1.1.2.6.1.0.6 netbsd-7-1-RELEASE:1.1.1.2.6.1 netbsd-7-1-RC2:1.1.1.2.6.1 clang-294123:1.1.1.5 netbsd-7-nhusb-base-20170116:1.1.1.2.6.1 bouyer-socketcan:1.1.1.5.0.2 bouyer-socketcan-base:1.1.1.5 clang-291444:1.1.1.5 pgoyette-localcount-20170107:1.1.1.4 netbsd-7-1-RC1:1.1.1.2.6.1 pgoyette-localcount-20161104:1.1.1.4 netbsd-7-0-2-RELEASE:1.1.1.2.6.1 localcount-20160914:1.1.1.4 netbsd-7-nhusb:1.1.1.2.6.1.0.4 netbsd-7-nhusb-base:1.1.1.2.6.1 clang-280599:1.1.1.4 pgoyette-localcount-20160806:1.1.1.4 pgoyette-localcount-20160726:1.1.1.4 pgoyette-localcount:1.1.1.4.0.2 pgoyette-localcount-base:1.1.1.4 netbsd-7-0-1-RELEASE:1.1.1.2.6.1 clang-261930:1.1.1.4 netbsd-7-0:1.1.1.2.6.1.0.2 netbsd-7-0-RELEASE:1.1.1.2.6.1 netbsd-7-0-RC3:1.1.1.2.6.1 netbsd-7-0-RC2:1.1.1.2.6.1 netbsd-7-0-RC1:1.1.1.2.6.1 clang-237755:1.1.1.3 clang-232565:1.1.1.3 clang-227398:1.1.1.3 tls-maxphys-base:1.1.1.2 tls-maxphys:1.1.1.2.0.8 netbsd-7:1.1.1.2.0.6 netbsd-7-base:1.1.1.2 clang-215315:1.1.1.2 clang-209886:1.1.1.2 yamt-pagecache:1.1.1.2.0.4 yamt-pagecache-base9:1.1.1.2 tls-earlyentropy:1.1.1.2.0.2 tls-earlyentropy-base:1.1.1.2 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.2 riastradh-drm2-base3:1.1.1.2 clang-202566:1.1.1.2 clang-201163:1.1.1.2 clang-199312:1.1.1.2 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.27; author joerg; state Exp; branches 1.1.1.2.4.1 1.1.1.2.6.1 1.1.1.2.8.1; next 1.1.1.3; commitid wh3aCSIWykURqWjx; 1.1.1.3 date 2015.01.29.19.57.32; author joerg; state Exp; branches; next 1.1.1.4; commitid mlISSizlPKvepX7y; 1.1.1.4 date 2016.02.27.22.11.52; author joerg; state Exp; branches 1.1.1.4.2.1; next 1.1.1.5; commitid tIimz3oDlh1NpBWy; 1.1.1.5 date 2017.01.11.10.35.42; author joerg; state Exp; branches 1.1.1.5.12.1 1.1.1.5.14.1; next 1.1.1.6; commitid CNnUNfII1jgNmxBz; 1.1.1.6 date 2018.07.17.18.31.04; author joerg; state Exp; branches; next 1.1.1.7; commitid wDzL46ALjrCZgwKA; 1.1.1.7 date 2019.11.13.22.19.20; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.2.4.1 date 2014.01.05.15.38.27; author yamt; state dead; branches; next 1.1.1.2.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.2.4.2 date 2014.05.22.16.18.26; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.2.6.1 date 2015.06.04.20.04.27; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.2.8.1 date 2014.01.05.15.38.27; author tls; state dead; branches; next 1.1.1.2.8.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.2.8.2 date 2014.08.19.23.47.26; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.4.2.1 date 2017.03.20.06.52.36; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.5.12.1 date 2018.07.28.04.33.16; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.5.14.1 date 2019.06.10.21.45.19; author christos; state Exp; branches; next 1.1.1.5.14.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.5.14.2 date 2020.04.13.07.46.30; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===--- ASTMatchersInternal.cpp - Structural query framework -------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // Implements the base layer of the matcher framework. // //===----------------------------------------------------------------------===// #include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchersInternal.h" namespace clang { namespace ast_matchers { namespace internal { void BoundNodesTreeBuilder::visitMatches(Visitor *ResultVisitor) { if (Bindings.empty()) Bindings.push_back(BoundNodesMap()); for (unsigned i = 0, e = Bindings.size(); i != e; ++i) { ResultVisitor->visitMatch(BoundNodes(Bindings[i])); } } DynTypedMatcher::MatcherStorage::~MatcherStorage() {} void BoundNodesTreeBuilder::addMatch(const BoundNodesTreeBuilder &Other) { for (unsigned i = 0, e = Other.Bindings.size(); i != e; ++i) { Bindings.push_back(Other.Bindings[i]); } } bool AllOfVariadicOperator(const ast_type_traits::DynTypedNode DynNode, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder, ArrayRef InnerMatchers) { // allOf leads to one matcher for each alternative in the first // matcher combined with each alternative in the second matcher. // Thus, we can reuse the same Builder. for (size_t i = 0, e = InnerMatchers.size(); i != e; ++i) { if (!InnerMatchers[i].matches(DynNode, Finder, Builder)) return false; } return true; } bool EachOfVariadicOperator(const ast_type_traits::DynTypedNode DynNode, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder, ArrayRef InnerMatchers) { BoundNodesTreeBuilder Result; bool Matched = false; for (size_t i = 0, e = InnerMatchers.size(); i != e; ++i) { BoundNodesTreeBuilder BuilderInner(*Builder); if (InnerMatchers[i].matches(DynNode, Finder, &BuilderInner)) { Matched = true; Result.addMatch(BuilderInner); } } *Builder = Result; return Matched; } bool AnyOfVariadicOperator(const ast_type_traits::DynTypedNode DynNode, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder, ArrayRef InnerMatchers) { for (size_t i = 0, e = InnerMatchers.size(); i != e; ++i) { BoundNodesTreeBuilder Result = *Builder; if (InnerMatchers[i].matches(DynNode, Finder, &Result)) { *Builder = Result; return true; } } return false; } } // end namespace internal } // end namespace ast_matchers } // end namespace clang @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.2 log @Import clang 3.5svn r198450. @ text @a36 20 bool NotUnaryOperator(const ast_type_traits::DynTypedNode DynNode, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder, ArrayRef InnerMatchers) { if (InnerMatchers.size() != 1) return false; // The 'unless' matcher will always discard the result: // If the inner matcher doesn't match, unless returns true, // but the inner matcher cannot have bound anything. // If the inner matcher matches, the result is false, and // any possible binding will be discarded. // We still need to hand in all the bound nodes up to this // point so the inner matcher can depend on bound nodes, // and we need to actively discard the bound nodes, otherwise // the inner matcher will reset the bound nodes if it doesn't // match, but this would be inversed by 'unless'. BoundNodesTreeBuilder Discard(*Builder); return !InnerMatchers[0].matches(DynNode, Finder, &Discard); } @ 1.1.1.2.6.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @a15 2 #include "llvm/ADT/SmallString.h" #include "llvm/Support/ManagedStatic.h" a20 20 bool NotUnaryOperator(const ast_type_traits::DynTypedNode DynNode, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder, ArrayRef InnerMatchers); bool AllOfVariadicOperator(const ast_type_traits::DynTypedNode DynNode, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder, ArrayRef InnerMatchers); bool EachOfVariadicOperator(const ast_type_traits::DynTypedNode DynNode, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder, ArrayRef InnerMatchers); bool AnyOfVariadicOperator(const ast_type_traits::DynTypedNode DynNode, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder, ArrayRef InnerMatchers); d24 2 a25 2 for (BoundNodesMap &Binding : Bindings) { ResultVisitor->visitMatch(BoundNodes(Binding)); d29 1 a29 1 namespace { d31 3 a33 105 typedef bool (*VariadicOperatorFunction)( const ast_type_traits::DynTypedNode DynNode, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder, ArrayRef InnerMatchers); template class VariadicMatcher : public DynMatcherInterface { public: VariadicMatcher(std::vector InnerMatchers) : InnerMatchers(std::move(InnerMatchers)) {} bool dynMatches(const ast_type_traits::DynTypedNode &DynNode, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder) const override { return Func(DynNode, Finder, Builder, InnerMatchers); } private: std::vector InnerMatchers; }; class IdDynMatcher : public DynMatcherInterface { public: IdDynMatcher(StringRef ID, const IntrusiveRefCntPtr &InnerMatcher) : ID(ID), InnerMatcher(InnerMatcher) {} bool dynMatches(const ast_type_traits::DynTypedNode &DynNode, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder) const override { bool Result = InnerMatcher->dynMatches(DynNode, Finder, Builder); if (Result) Builder->setBinding(ID, DynNode); return Result; } private: const std::string ID; const IntrusiveRefCntPtr InnerMatcher; }; /// \brief A matcher that always returns true. /// /// We only ever need one instance of this matcher, so we create a global one /// and reuse it to reduce the overhead of the matcher and increase the chance /// of cache hits. class TrueMatcherImpl : public DynMatcherInterface { public: TrueMatcherImpl() { Retain(); // Reference count will never become zero. } bool dynMatches(const ast_type_traits::DynTypedNode &, ASTMatchFinder *, BoundNodesTreeBuilder *) const override { return true; } }; static llvm::ManagedStatic TrueMatcherInstance; } // namespace DynTypedMatcher DynTypedMatcher::constructVariadic( DynTypedMatcher::VariadicOperator Op, std::vector InnerMatchers) { assert(InnerMatchers.size() > 0 && "Array must not be empty."); assert(std::all_of(InnerMatchers.begin(), InnerMatchers.end(), [&InnerMatchers](const DynTypedMatcher &M) { return InnerMatchers[0].SupportedKind.isSame(M.SupportedKind); }) && "SupportedKind must match!"); auto SupportedKind = InnerMatchers[0].SupportedKind; // We must relax the restrict kind here. // The different operators might deal differently with a mismatch. // Make it the same as SupportedKind, since that is the broadest type we are // allowed to accept. auto RestrictKind = SupportedKind; switch (Op) { case VO_AllOf: // In the case of allOf() we must pass all the checks, so making // RestrictKind the most restrictive can save us time. This way we reject // invalid types earlier and we can elide the kind checks inside the // matcher. for (auto &IM : InnerMatchers) { RestrictKind = ast_type_traits::ASTNodeKind::getMostDerivedType( RestrictKind, IM.RestrictKind); } return DynTypedMatcher( SupportedKind, RestrictKind, new VariadicMatcher(std::move(InnerMatchers))); case VO_AnyOf: return DynTypedMatcher( SupportedKind, RestrictKind, new VariadicMatcher(std::move(InnerMatchers))); case VO_EachOf: return DynTypedMatcher( SupportedKind, RestrictKind, new VariadicMatcher(std::move(InnerMatchers))); case VO_UnaryNot: // FIXME: Implement the Not operator to take a single matcher instead of a // vector. return DynTypedMatcher( SupportedKind, RestrictKind, new VariadicMatcher(std::move(InnerMatchers))); a34 70 llvm_unreachable("Invalid Op value."); } DynTypedMatcher DynTypedMatcher::trueMatcher( ast_type_traits::ASTNodeKind NodeKind) { return DynTypedMatcher(NodeKind, NodeKind, &*TrueMatcherInstance); } bool DynTypedMatcher::canMatchNodesOfKind( ast_type_traits::ASTNodeKind Kind) const { return RestrictKind.isBaseOf(Kind); } DynTypedMatcher DynTypedMatcher::dynCastTo( const ast_type_traits::ASTNodeKind Kind) const { auto Copy = *this; Copy.SupportedKind = Kind; Copy.RestrictKind = ast_type_traits::ASTNodeKind::getMostDerivedType(Kind, RestrictKind); return Copy; } bool DynTypedMatcher::matches(const ast_type_traits::DynTypedNode &DynNode, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder) const { if (RestrictKind.isBaseOf(DynNode.getNodeKind()) && Implementation->dynMatches(DynNode, Finder, Builder)) { return true; } // Delete all bindings when a matcher does not match. // This prevents unexpected exposure of bound nodes in unmatches // branches of the match tree. Builder->removeBindings([](const BoundNodesMap &) { return true; }); return false; } bool DynTypedMatcher::matchesNoKindCheck( const ast_type_traits::DynTypedNode &DynNode, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder) const { assert(RestrictKind.isBaseOf(DynNode.getNodeKind())); if (Implementation->dynMatches(DynNode, Finder, Builder)) { return true; } // Delete all bindings when a matcher does not match. // This prevents unexpected exposure of bound nodes in unmatches // branches of the match tree. Builder->removeBindings([](const BoundNodesMap &) { return true; }); return false; } llvm::Optional DynTypedMatcher::tryBind(StringRef ID) const { if (!AllowBind) return llvm::None; auto Result = *this; Result.Implementation = new IdDynMatcher(ID, Result.Implementation); return Result; } bool DynTypedMatcher::canConvertTo(ast_type_traits::ASTNodeKind To) const { const auto From = getSupportedKind(); auto QualKind = ast_type_traits::ASTNodeKind::getFromNodeKind(); auto TypeKind = ast_type_traits::ASTNodeKind::getFromNodeKind(); /// Mimic the implicit conversions of Matcher<>. /// - From Matcher to Matcher if (From.isSame(TypeKind) && To.isSame(QualKind)) return true; /// - From Matcher to Matcher return From.isBaseOf(To); } void BoundNodesTreeBuilder::addMatch(const BoundNodesTreeBuilder &Other) { Bindings.append(Other.Bindings.begin(), Other.Bindings.end()); d64 2 a65 2 for (const DynTypedMatcher &InnerMatcher : InnerMatchers) { if (!InnerMatcher.matchesNoKindCheck(DynNode, Finder, Builder)) d77 1 a77 1 for (const DynTypedMatcher &InnerMatcher : InnerMatchers) { d79 1 a79 1 if (InnerMatcher.matches(DynNode, Finder, &BuilderInner)) { d84 1 a84 1 *Builder = std::move(Result); d92 1 a92 1 for (const DynTypedMatcher &InnerMatcher : InnerMatchers) { d94 2 a95 2 if (InnerMatcher.matches(DynNode, Finder, &Result)) { *Builder = std::move(Result); a101 46 HasNameMatcher::HasNameMatcher(StringRef NameRef) : UseUnqualifiedMatch(NameRef.find("::") == NameRef.npos), Name(NameRef) { assert(!Name.empty()); } bool HasNameMatcher::matchesNodeUnqualified(const NamedDecl &Node) const { assert(UseUnqualifiedMatch); if (Node.getIdentifier()) { // Simple name. return Name == Node.getName(); } if (Node.getDeclName()) { // Name needs to be constructed. llvm::SmallString<128> NodeName; llvm::raw_svector_ostream OS(NodeName); Node.printName(OS); return Name == OS.str(); } return false; } bool HasNameMatcher::matchesNodeFull(const NamedDecl &Node) const { llvm::SmallString<128> NodeName = StringRef("::"); llvm::raw_svector_ostream OS(NodeName); Node.printQualifiedName(OS); const StringRef FullName = OS.str(); const StringRef Pattern = Name; if (Pattern.startswith("::")) return FullName == Pattern; return FullName.endswith(Pattern) && FullName.drop_back(Pattern.size()).endswith("::"); } bool HasNameMatcher::matchesNode(const NamedDecl &Node) const { // FIXME: There is still room for improvement, but it would require copying a // lot of the logic from NamedDecl::printQualifiedName(). The benchmarks do // not show like that extra complexity is needed right now. if (UseUnqualifiedMatch) { assert(matchesNodeUnqualified(Node) == matchesNodeFull(Node)); return matchesNodeUnqualified(Node); } return matchesNodeFull(Node); } @ 1.1.1.3 log @Import Clang 3.6RC1 r227398. @ text @a15 2 #include "llvm/ADT/SmallString.h" #include "llvm/Support/ManagedStatic.h" a20 20 bool NotUnaryOperator(const ast_type_traits::DynTypedNode DynNode, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder, ArrayRef InnerMatchers); bool AllOfVariadicOperator(const ast_type_traits::DynTypedNode DynNode, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder, ArrayRef InnerMatchers); bool EachOfVariadicOperator(const ast_type_traits::DynTypedNode DynNode, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder, ArrayRef InnerMatchers); bool AnyOfVariadicOperator(const ast_type_traits::DynTypedNode DynNode, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder, ArrayRef InnerMatchers); d24 2 a25 2 for (BoundNodesMap &Binding : Bindings) { ResultVisitor->visitMatch(BoundNodes(Binding)); d29 1 a29 1 namespace { d31 3 a33 105 typedef bool (*VariadicOperatorFunction)( const ast_type_traits::DynTypedNode DynNode, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder, ArrayRef InnerMatchers); template class VariadicMatcher : public DynMatcherInterface { public: VariadicMatcher(std::vector InnerMatchers) : InnerMatchers(std::move(InnerMatchers)) {} bool dynMatches(const ast_type_traits::DynTypedNode &DynNode, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder) const override { return Func(DynNode, Finder, Builder, InnerMatchers); } private: std::vector InnerMatchers; }; class IdDynMatcher : public DynMatcherInterface { public: IdDynMatcher(StringRef ID, const IntrusiveRefCntPtr &InnerMatcher) : ID(ID), InnerMatcher(InnerMatcher) {} bool dynMatches(const ast_type_traits::DynTypedNode &DynNode, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder) const override { bool Result = InnerMatcher->dynMatches(DynNode, Finder, Builder); if (Result) Builder->setBinding(ID, DynNode); return Result; } private: const std::string ID; const IntrusiveRefCntPtr InnerMatcher; }; /// \brief A matcher that always returns true. /// /// We only ever need one instance of this matcher, so we create a global one /// and reuse it to reduce the overhead of the matcher and increase the chance /// of cache hits. class TrueMatcherImpl : public DynMatcherInterface { public: TrueMatcherImpl() { Retain(); // Reference count will never become zero. } bool dynMatches(const ast_type_traits::DynTypedNode &, ASTMatchFinder *, BoundNodesTreeBuilder *) const override { return true; } }; static llvm::ManagedStatic TrueMatcherInstance; } // namespace DynTypedMatcher DynTypedMatcher::constructVariadic( DynTypedMatcher::VariadicOperator Op, std::vector InnerMatchers) { assert(InnerMatchers.size() > 0 && "Array must not be empty."); assert(std::all_of(InnerMatchers.begin(), InnerMatchers.end(), [&InnerMatchers](const DynTypedMatcher &M) { return InnerMatchers[0].SupportedKind.isSame(M.SupportedKind); }) && "SupportedKind must match!"); auto SupportedKind = InnerMatchers[0].SupportedKind; // We must relax the restrict kind here. // The different operators might deal differently with a mismatch. // Make it the same as SupportedKind, since that is the broadest type we are // allowed to accept. auto RestrictKind = SupportedKind; switch (Op) { case VO_AllOf: // In the case of allOf() we must pass all the checks, so making // RestrictKind the most restrictive can save us time. This way we reject // invalid types earlier and we can elide the kind checks inside the // matcher. for (auto &IM : InnerMatchers) { RestrictKind = ast_type_traits::ASTNodeKind::getMostDerivedType( RestrictKind, IM.RestrictKind); } return DynTypedMatcher( SupportedKind, RestrictKind, new VariadicMatcher(std::move(InnerMatchers))); case VO_AnyOf: return DynTypedMatcher( SupportedKind, RestrictKind, new VariadicMatcher(std::move(InnerMatchers))); case VO_EachOf: return DynTypedMatcher( SupportedKind, RestrictKind, new VariadicMatcher(std::move(InnerMatchers))); case VO_UnaryNot: // FIXME: Implement the Not operator to take a single matcher instead of a // vector. return DynTypedMatcher( SupportedKind, RestrictKind, new VariadicMatcher(std::move(InnerMatchers))); a34 70 llvm_unreachable("Invalid Op value."); } DynTypedMatcher DynTypedMatcher::trueMatcher( ast_type_traits::ASTNodeKind NodeKind) { return DynTypedMatcher(NodeKind, NodeKind, &*TrueMatcherInstance); } bool DynTypedMatcher::canMatchNodesOfKind( ast_type_traits::ASTNodeKind Kind) const { return RestrictKind.isBaseOf(Kind); } DynTypedMatcher DynTypedMatcher::dynCastTo( const ast_type_traits::ASTNodeKind Kind) const { auto Copy = *this; Copy.SupportedKind = Kind; Copy.RestrictKind = ast_type_traits::ASTNodeKind::getMostDerivedType(Kind, RestrictKind); return Copy; } bool DynTypedMatcher::matches(const ast_type_traits::DynTypedNode &DynNode, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder) const { if (RestrictKind.isBaseOf(DynNode.getNodeKind()) && Implementation->dynMatches(DynNode, Finder, Builder)) { return true; } // Delete all bindings when a matcher does not match. // This prevents unexpected exposure of bound nodes in unmatches // branches of the match tree. Builder->removeBindings([](const BoundNodesMap &) { return true; }); return false; } bool DynTypedMatcher::matchesNoKindCheck( const ast_type_traits::DynTypedNode &DynNode, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder) const { assert(RestrictKind.isBaseOf(DynNode.getNodeKind())); if (Implementation->dynMatches(DynNode, Finder, Builder)) { return true; } // Delete all bindings when a matcher does not match. // This prevents unexpected exposure of bound nodes in unmatches // branches of the match tree. Builder->removeBindings([](const BoundNodesMap &) { return true; }); return false; } llvm::Optional DynTypedMatcher::tryBind(StringRef ID) const { if (!AllowBind) return llvm::None; auto Result = *this; Result.Implementation = new IdDynMatcher(ID, Result.Implementation); return Result; } bool DynTypedMatcher::canConvertTo(ast_type_traits::ASTNodeKind To) const { const auto From = getSupportedKind(); auto QualKind = ast_type_traits::ASTNodeKind::getFromNodeKind(); auto TypeKind = ast_type_traits::ASTNodeKind::getFromNodeKind(); /// Mimic the implicit conversions of Matcher<>. /// - From Matcher to Matcher if (From.isSame(TypeKind) && To.isSame(QualKind)) return true; /// - From Matcher to Matcher return From.isBaseOf(To); } void BoundNodesTreeBuilder::addMatch(const BoundNodesTreeBuilder &Other) { Bindings.append(Other.Bindings.begin(), Other.Bindings.end()); d64 2 a65 2 for (const DynTypedMatcher &InnerMatcher : InnerMatchers) { if (!InnerMatcher.matchesNoKindCheck(DynNode, Finder, Builder)) d77 1 a77 1 for (const DynTypedMatcher &InnerMatcher : InnerMatchers) { d79 1 a79 1 if (InnerMatcher.matches(DynNode, Finder, &BuilderInner)) { d84 1 a84 1 *Builder = std::move(Result); d92 1 a92 1 for (const DynTypedMatcher &InnerMatcher : InnerMatchers) { d94 2 a95 2 if (InnerMatcher.matches(DynNode, Finder, &Result)) { *Builder = std::move(Result); a101 46 HasNameMatcher::HasNameMatcher(StringRef NameRef) : UseUnqualifiedMatch(NameRef.find("::") == NameRef.npos), Name(NameRef) { assert(!Name.empty()); } bool HasNameMatcher::matchesNodeUnqualified(const NamedDecl &Node) const { assert(UseUnqualifiedMatch); if (Node.getIdentifier()) { // Simple name. return Name == Node.getName(); } if (Node.getDeclName()) { // Name needs to be constructed. llvm::SmallString<128> NodeName; llvm::raw_svector_ostream OS(NodeName); Node.printName(OS); return Name == OS.str(); } return false; } bool HasNameMatcher::matchesNodeFull(const NamedDecl &Node) const { llvm::SmallString<128> NodeName = StringRef("::"); llvm::raw_svector_ostream OS(NodeName); Node.printQualifiedName(OS); const StringRef FullName = OS.str(); const StringRef Pattern = Name; if (Pattern.startswith("::")) return FullName == Pattern; return FullName.endswith(Pattern) && FullName.drop_back(Pattern.size()).endswith("::"); } bool HasNameMatcher::matchesNode(const NamedDecl &Node) const { // FIXME: There is still room for improvement, but it would require copying a // lot of the logic from NamedDecl::printQualifiedName(). The benchmarks do // not show like that extra complexity is needed right now. if (UseUnqualifiedMatch) { assert(matchesNodeUnqualified(Node) == matchesNodeFull(Node)); return matchesNodeUnqualified(Node); } return matchesNodeFull(Node); } @ 1.1.1.4 log @Import Clang 3.8.0rc3 r261930. @ text @d23 1 a23 1 bool NotUnaryOperator(const ast_type_traits::DynTypedNode &DynNode, d27 1 a27 1 bool AllOfVariadicOperator(const ast_type_traits::DynTypedNode &DynNode, d32 1 a32 1 bool EachOfVariadicOperator(const ast_type_traits::DynTypedNode &DynNode, d37 1 a37 1 bool AnyOfVariadicOperator(const ast_type_traits::DynTypedNode &DynNode, d54 1 a54 1 const ast_type_traits::DynTypedNode &DynNode, ASTMatchFinder *Finder, a112 1 ast_type_traits::ASTNodeKind SupportedKind, d116 4 a119 4 [SupportedKind](const DynTypedMatcher &M) { return M.canConvertTo(SupportedKind); }) && "InnerMatchers must be convertible to SupportedKind!"); d121 1 d231 1 a231 1 bool NotUnaryOperator(const ast_type_traits::DynTypedNode &DynNode, d251 1 a251 1 bool AllOfVariadicOperator(const ast_type_traits::DynTypedNode &DynNode, d265 1 a265 1 bool EachOfVariadicOperator(const ast_type_traits::DynTypedNode &DynNode, d282 1 a282 1 bool AnyOfVariadicOperator(const ast_type_traits::DynTypedNode &DynNode, @ 1.1.1.4.2.1 log @Sync with HEAD @ text @a16 1 #include "llvm/ADT/SmallVector.h" d74 1 a74 1 public: d76 2 a77 2 IntrusiveRefCntPtr InnerMatcher) : ID(ID), InnerMatcher(std::move(InnerMatcher)) {} d87 1 a87 1 private: d212 2 a213 3 Result.Implementation = new IdDynMatcher(ID, std::move(Result.Implementation)); return std::move(Result); d296 3 a298 17 Matcher hasAnyNameFunc(ArrayRef NameRefs) { std::vector Names; for (auto *Name : NameRefs) Names.emplace_back(*Name); return internal::Matcher( new internal::HasNameMatcher(std::move(Names))); } HasNameMatcher::HasNameMatcher(std::vector N) : UseUnqualifiedMatch(std::all_of( N.begin(), N.end(), [](StringRef Name) { return Name.find("::") == Name.npos; })), Names(std::move(N)) { #ifndef NDEBUG for (StringRef Name : Names) assert(!Name.empty()); #endif d301 5 a305 11 namespace { bool consumeNameSuffix(StringRef &FullName, StringRef Suffix) { StringRef Name = FullName; if (!Name.endswith(Suffix)) return false; Name = Name.drop_back(Suffix.size()); if (!Name.empty()) { if (!Name.endswith("::")) return false; Name = Name.drop_back(2); a306 9 FullName = Name; return true; } StringRef getNodeName(const NamedDecl &Node, llvm::SmallString<128> &Scratch) { // Simple name. if (Node.getIdentifier()) return Node.getName(); d309 2 a310 2 Scratch.clear(); llvm::raw_svector_ostream OS(Scratch); d312 1 a312 1 return OS.str(); d314 1 a314 10 return "(anonymous)"; } StringRef getNodeName(const RecordDecl &Node, llvm::SmallString<128> &Scratch) { if (Node.getIdentifier()) { return Node.getName(); } Scratch.clear(); return ("(anonymous " + Node.getKindName() + ")").toStringRef(Scratch); d317 6 a322 4 StringRef getNodeName(const NamespaceDecl &Node, llvm::SmallString<128> &Scratch) { return Node.isAnonymousNamespace() ? "(anonymous namespace)" : Node.getName(); } d324 2 d327 2 a328 132 class PatternSet { public: PatternSet(ArrayRef Names) { for (StringRef Name : Names) Patterns.push_back({Name, Name.startswith("::")}); } /// Consumes the name suffix from each pattern in the set and removes the ones /// that didn't match. /// Return true if there are still any patterns left. bool consumeNameSuffix(StringRef NodeName, bool CanSkip) { for (size_t I = 0; I < Patterns.size();) { if (internal::consumeNameSuffix(Patterns[I].P, NodeName) || CanSkip) { ++I; } else { Patterns.erase(Patterns.begin() + I); } } return !Patterns.empty(); } /// Check if any of the patterns are a match. /// A match will be a pattern that was fully consumed, that also matches the /// 'fully qualified' requirement. bool foundMatch(bool AllowFullyQualified) const { for (auto& P: Patterns) if (P.P.empty() && (AllowFullyQualified || !P.IsFullyQualified)) return true; return false; } private: struct Pattern { StringRef P; bool IsFullyQualified; }; llvm::SmallVector Patterns; }; } // namespace 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 consumeNameSuffix(Name, NodeName) && Name.empty(); }); } bool HasNameMatcher::matchesNodeFullFast(const NamedDecl &Node) const { PatternSet Patterns(Names); llvm::SmallString<128> Scratch; // This function is copied and adapted from NamedDecl::printQualifiedName() // By matching each part individually we optimize in a couple of ways: // - We can exit early on the first failure. // - We can skip inline/anonymous namespaces without another pass. // - We print one name at a time, reducing the chance of overflowing the // inlined space of the SmallString. // First, match the name. if (!Patterns.consumeNameSuffix(getNodeName(Node, Scratch), /*CanSkip=*/false)) return false; // Try to match each declaration context. // We are allowed to skip anonymous and inline namespaces if they don't match. const DeclContext *Ctx = Node.getDeclContext(); if (Ctx->isFunctionOrMethod()) return Patterns.foundMatch(/*AllowFullyQualified=*/false); for (; Ctx && isa(Ctx); Ctx = Ctx->getParent()) { if (Patterns.foundMatch(/*AllowFullyQualified=*/false)) return true; if (const auto *ND = dyn_cast(Ctx)) { // If it matches (or we can skip it), continue. if (Patterns.consumeNameSuffix(getNodeName(*ND, Scratch), /*CanSkip=*/ND->isAnonymousNamespace() || ND->isInline())) continue; return false; } if (const auto *RD = dyn_cast(Ctx)) { if (!isa(Ctx)) { if (Patterns.consumeNameSuffix(getNodeName(*RD, Scratch), /*CanSkip=*/false)) continue; return false; } } // We don't know how to deal with this DeclContext. // Fallback to the slow version of the code. return matchesNodeFullSlow(Node); } return Patterns.foundMatch(/*AllowFullyQualified=*/true); } bool HasNameMatcher::matchesNodeFullSlow(const NamedDecl &Node) const { const bool SkipUnwrittenCases[] = {false, true}; for (bool SkipUnwritten : SkipUnwrittenCases) { llvm::SmallString<128> NodeName = StringRef("::"); llvm::raw_svector_ostream OS(NodeName); if (SkipUnwritten) { PrintingPolicy Policy = Node.getASTContext().getPrintingPolicy(); Policy.SuppressUnwrittenScope = true; Node.printQualifiedName(OS, Policy); } else { Node.printQualifiedName(OS); } const StringRef FullName = OS.str(); for (const StringRef Pattern : Names) { if (Pattern.startswith("::")) { if (FullName == Pattern) return true; } else if (FullName.endswith(Pattern) && FullName.drop_back(Pattern.size()).endswith("::")) { return true; } } } return false; d332 3 a334 1 assert(matchesNodeFullFast(Node) == matchesNodeFullSlow(Node)); d336 1 a336 1 assert(matchesNodeUnqualified(Node) == matchesNodeFullFast(Node)); d339 1 a339 1 return matchesNodeFullFast(Node); @ 1.1.1.5 log @Import Clang pre-4.0.0 r291444. @ text @a16 1 #include "llvm/ADT/SmallVector.h" d74 1 a74 1 public: d76 2 a77 2 IntrusiveRefCntPtr InnerMatcher) : ID(ID), InnerMatcher(std::move(InnerMatcher)) {} d87 1 a87 1 private: d212 2 a213 3 Result.Implementation = new IdDynMatcher(ID, std::move(Result.Implementation)); return std::move(Result); d296 3 a298 17 Matcher hasAnyNameFunc(ArrayRef NameRefs) { std::vector Names; for (auto *Name : NameRefs) Names.emplace_back(*Name); return internal::Matcher( new internal::HasNameMatcher(std::move(Names))); } HasNameMatcher::HasNameMatcher(std::vector N) : UseUnqualifiedMatch(std::all_of( N.begin(), N.end(), [](StringRef Name) { return Name.find("::") == Name.npos; })), Names(std::move(N)) { #ifndef NDEBUG for (StringRef Name : Names) assert(!Name.empty()); #endif d301 5 a305 11 namespace { bool consumeNameSuffix(StringRef &FullName, StringRef Suffix) { StringRef Name = FullName; if (!Name.endswith(Suffix)) return false; Name = Name.drop_back(Suffix.size()); if (!Name.empty()) { if (!Name.endswith("::")) return false; Name = Name.drop_back(2); a306 9 FullName = Name; return true; } StringRef getNodeName(const NamedDecl &Node, llvm::SmallString<128> &Scratch) { // Simple name. if (Node.getIdentifier()) return Node.getName(); d309 2 a310 2 Scratch.clear(); llvm::raw_svector_ostream OS(Scratch); d312 1 a312 1 return OS.str(); d314 1 a314 10 return "(anonymous)"; } StringRef getNodeName(const RecordDecl &Node, llvm::SmallString<128> &Scratch) { if (Node.getIdentifier()) { return Node.getName(); } Scratch.clear(); return ("(anonymous " + Node.getKindName() + ")").toStringRef(Scratch); d317 6 a322 4 StringRef getNodeName(const NamespaceDecl &Node, llvm::SmallString<128> &Scratch) { return Node.isAnonymousNamespace() ? "(anonymous namespace)" : Node.getName(); } d324 2 d327 2 a328 132 class PatternSet { public: PatternSet(ArrayRef Names) { for (StringRef Name : Names) Patterns.push_back({Name, Name.startswith("::")}); } /// Consumes the name suffix from each pattern in the set and removes the ones /// that didn't match. /// Return true if there are still any patterns left. bool consumeNameSuffix(StringRef NodeName, bool CanSkip) { for (size_t I = 0; I < Patterns.size();) { if (internal::consumeNameSuffix(Patterns[I].P, NodeName) || CanSkip) { ++I; } else { Patterns.erase(Patterns.begin() + I); } } return !Patterns.empty(); } /// Check if any of the patterns are a match. /// A match will be a pattern that was fully consumed, that also matches the /// 'fully qualified' requirement. bool foundMatch(bool AllowFullyQualified) const { for (auto& P: Patterns) if (P.P.empty() && (AllowFullyQualified || !P.IsFullyQualified)) return true; return false; } private: struct Pattern { StringRef P; bool IsFullyQualified; }; llvm::SmallVector Patterns; }; } // namespace 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 consumeNameSuffix(Name, NodeName) && Name.empty(); }); } bool HasNameMatcher::matchesNodeFullFast(const NamedDecl &Node) const { PatternSet Patterns(Names); llvm::SmallString<128> Scratch; // This function is copied and adapted from NamedDecl::printQualifiedName() // By matching each part individually we optimize in a couple of ways: // - We can exit early on the first failure. // - We can skip inline/anonymous namespaces without another pass. // - We print one name at a time, reducing the chance of overflowing the // inlined space of the SmallString. // First, match the name. if (!Patterns.consumeNameSuffix(getNodeName(Node, Scratch), /*CanSkip=*/false)) return false; // Try to match each declaration context. // We are allowed to skip anonymous and inline namespaces if they don't match. const DeclContext *Ctx = Node.getDeclContext(); if (Ctx->isFunctionOrMethod()) return Patterns.foundMatch(/*AllowFullyQualified=*/false); for (; Ctx && isa(Ctx); Ctx = Ctx->getParent()) { if (Patterns.foundMatch(/*AllowFullyQualified=*/false)) return true; if (const auto *ND = dyn_cast(Ctx)) { // If it matches (or we can skip it), continue. if (Patterns.consumeNameSuffix(getNodeName(*ND, Scratch), /*CanSkip=*/ND->isAnonymousNamespace() || ND->isInline())) continue; return false; } if (const auto *RD = dyn_cast(Ctx)) { if (!isa(Ctx)) { if (Patterns.consumeNameSuffix(getNodeName(*RD, Scratch), /*CanSkip=*/false)) continue; return false; } } // We don't know how to deal with this DeclContext. // Fallback to the slow version of the code. return matchesNodeFullSlow(Node); } return Patterns.foundMatch(/*AllowFullyQualified=*/true); } bool HasNameMatcher::matchesNodeFullSlow(const NamedDecl &Node) const { const bool SkipUnwrittenCases[] = {false, true}; for (bool SkipUnwritten : SkipUnwrittenCases) { llvm::SmallString<128> NodeName = StringRef("::"); llvm::raw_svector_ostream OS(NodeName); if (SkipUnwritten) { PrintingPolicy Policy = Node.getASTContext().getPrintingPolicy(); Policy.SuppressUnwrittenScope = true; Node.printQualifiedName(OS, Policy); } else { Node.printQualifiedName(OS); } const StringRef FullName = OS.str(); for (const StringRef Pattern : Names) { if (Pattern.startswith("::")) { if (FullName == Pattern) return true; } else if (FullName.endswith(Pattern) && FullName.drop_back(Pattern.size()).endswith("::")) { return true; } } } return false; d332 3 a334 1 assert(matchesNodeFullFast(Node) == matchesNodeFullSlow(Node)); d336 1 a336 1 assert(matchesNodeUnqualified(Node) == matchesNodeFullFast(Node)); d339 1 a339 1 return matchesNodeFullFast(Node); @ 1.1.1.5.14.1 log @Sync with HEAD @ text @d1 1 a1 1 //===- ASTMatchersInternal.cpp - Structural query framework ---------------===// d14 1 a15 10 #include "clang/AST/ASTContext.h" #include "clang/AST/ASTTypeTraits.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/PrettyPrinter.h" #include "clang/ASTMatchers/ASTMatchers.h" #include "clang/Basic/LLVM.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/IntrusiveRefCntPtr.h" #include "llvm/ADT/None.h" a17 3 #include "llvm/ADT/StringRef.h" #include "llvm/Support/Casting.h" #include "llvm/Support/ErrorHandling.h" a18 7 #include "llvm/Support/raw_ostream.h" #include #include #include #include #include #include a21 10 AST_MATCHER_P(ObjCMessageExpr, hasAnySelectorMatcher, std::vector, Matches) { std::string SelString = Node.getSelector().getAsString(); for (const std::string &S : Matches) if (S == SelString) return true; return false; } d43 1 d54 1 a54 1 using VariadicOperatorFunction = bool (*)( d93 1 a93 1 /// A matcher that always returns true. a102 1 d108 1 d110 1 a110 3 } // namespace static llvm::ManagedStatic TrueMatcherInstance; d116 1 a116 1 assert(!InnerMatchers.empty() && "Array must not be empty."); d298 1 a298 2 inline static std::vector vectorFromRefs(ArrayRef NameRefs) { d302 2 a303 11 return Names; } Matcher hasAnyNameFunc(ArrayRef NameRefs) { std::vector Names = vectorFromRefs(NameRefs); return internal::Matcher(new internal::HasNameMatcher(Names)); } Matcher hasAnySelectorFunc( ArrayRef NameRefs) { return hasAnySelectorMatcher(vectorFromRefs(NameRefs)); d317 3 a319 1 static bool consumeNameSuffix(StringRef &FullName, StringRef Suffix) { d333 1 a333 2 static StringRef getNodeName(const NamedDecl &Node, llvm::SmallString<128> &Scratch) { d349 1 a349 2 static StringRef getNodeName(const RecordDecl &Node, llvm::SmallString<128> &Scratch) { d357 2 a358 2 static StringRef getNodeName(const NamespaceDecl &Node, llvm::SmallString<128> &Scratch) { a361 1 namespace { d375 1 a375 2 if (::clang::ast_matchers::internal::consumeNameSuffix(Patterns[I].P, NodeName) || a399 1 d403 1 a403 1 } // namespace a506 284 const internal::VariadicDynCastAllOfMatcher autoreleasePoolStmt; const internal::VariadicDynCastAllOfMatcher translationUnitDecl; const internal::VariadicDynCastAllOfMatcher typedefDecl; const internal::VariadicDynCastAllOfMatcher typedefNameDecl; const internal::VariadicDynCastAllOfMatcher typeAliasDecl; const internal::VariadicDynCastAllOfMatcher typeAliasTemplateDecl; const internal::VariadicAllOfMatcher decl; const internal::VariadicDynCastAllOfMatcher linkageSpecDecl; const internal::VariadicDynCastAllOfMatcher namedDecl; const internal::VariadicDynCastAllOfMatcher labelDecl; const internal::VariadicDynCastAllOfMatcher namespaceDecl; const internal::VariadicDynCastAllOfMatcher namespaceAliasDecl; const internal::VariadicDynCastAllOfMatcher recordDecl; const internal::VariadicDynCastAllOfMatcher cxxRecordDecl; const internal::VariadicDynCastAllOfMatcher classTemplateDecl; const internal::VariadicDynCastAllOfMatcher classTemplateSpecializationDecl; const internal::VariadicDynCastAllOfMatcher declaratorDecl; const internal::VariadicDynCastAllOfMatcher parmVarDecl; const internal::VariadicDynCastAllOfMatcher accessSpecDecl; const internal::VariadicAllOfMatcher cxxCtorInitializer; const internal::VariadicAllOfMatcher templateArgument; const internal::VariadicAllOfMatcher templateName; const internal::VariadicDynCastAllOfMatcher nonTypeTemplateParmDecl; const internal::VariadicDynCastAllOfMatcher templateTypeParmDecl; const internal::VariadicAllOfMatcher qualType; const internal::VariadicAllOfMatcher type; const internal::VariadicAllOfMatcher typeLoc; const internal::VariadicDynCastAllOfMatcher unaryExprOrTypeTraitExpr; const internal::VariadicDynCastAllOfMatcher valueDecl; const internal::VariadicDynCastAllOfMatcher cxxConstructorDecl; const internal::VariadicDynCastAllOfMatcher cxxDestructorDecl; const internal::VariadicDynCastAllOfMatcher enumDecl; const internal::VariadicDynCastAllOfMatcher enumConstantDecl; const internal::VariadicDynCastAllOfMatcher cxxMethodDecl; const internal::VariadicDynCastAllOfMatcher cxxConversionDecl; const internal::VariadicDynCastAllOfMatcher varDecl; const internal::VariadicDynCastAllOfMatcher fieldDecl; const internal::VariadicDynCastAllOfMatcher functionDecl; const internal::VariadicDynCastAllOfMatcher functionTemplateDecl; const internal::VariadicDynCastAllOfMatcher friendDecl; const internal::VariadicAllOfMatcher stmt; const internal::VariadicDynCastAllOfMatcher declStmt; const internal::VariadicDynCastAllOfMatcher memberExpr; const internal::VariadicDynCastAllOfMatcher callExpr; const internal::VariadicDynCastAllOfMatcher lambdaExpr; const internal::VariadicDynCastAllOfMatcher cxxMemberCallExpr; const internal::VariadicDynCastAllOfMatcher objcMessageExpr; const internal::VariadicDynCastAllOfMatcher objcInterfaceDecl; const internal::VariadicDynCastAllOfMatcher objcImplementationDecl; const internal::VariadicDynCastAllOfMatcher objcProtocolDecl; const internal::VariadicDynCastAllOfMatcher objcCategoryDecl; const internal::VariadicDynCastAllOfMatcher objcCategoryImplDecl; const internal::VariadicDynCastAllOfMatcher objcMethodDecl; const internal::VariadicDynCastAllOfMatcher blockDecl; const internal::VariadicDynCastAllOfMatcher objcIvarDecl; const internal::VariadicDynCastAllOfMatcher objcPropertyDecl; const internal::VariadicDynCastAllOfMatcher objcThrowStmt; const internal::VariadicDynCastAllOfMatcher objcTryStmt; const internal::VariadicDynCastAllOfMatcher objcCatchStmt; const internal::VariadicDynCastAllOfMatcher objcFinallyStmt; const internal::VariadicDynCastAllOfMatcher exprWithCleanups; const internal::VariadicDynCastAllOfMatcher initListExpr; const internal::VariadicDynCastAllOfMatcher cxxStdInitializerListExpr; const internal::VariadicDynCastAllOfMatcher implicitValueInitExpr; const internal::VariadicDynCastAllOfMatcher parenListExpr; const internal::VariadicDynCastAllOfMatcher substNonTypeTemplateParmExpr; const internal::VariadicDynCastAllOfMatcher usingDecl; const internal::VariadicDynCastAllOfMatcher usingDirectiveDecl; const internal::VariadicDynCastAllOfMatcher unresolvedLookupExpr; const internal::VariadicDynCastAllOfMatcher unresolvedUsingValueDecl; const internal::VariadicDynCastAllOfMatcher unresolvedUsingTypenameDecl; const internal::VariadicDynCastAllOfMatcher parenExpr; const internal::VariadicDynCastAllOfMatcher cxxConstructExpr; const internal::VariadicDynCastAllOfMatcher cxxUnresolvedConstructExpr; const internal::VariadicDynCastAllOfMatcher cxxThisExpr; const internal::VariadicDynCastAllOfMatcher cxxBindTemporaryExpr; const internal::VariadicDynCastAllOfMatcher materializeTemporaryExpr; const internal::VariadicDynCastAllOfMatcher cxxNewExpr; const internal::VariadicDynCastAllOfMatcher cxxDeleteExpr; const internal::VariadicDynCastAllOfMatcher arraySubscriptExpr; const internal::VariadicDynCastAllOfMatcher cxxDefaultArgExpr; const internal::VariadicDynCastAllOfMatcher cxxOperatorCallExpr; const internal::VariadicDynCastAllOfMatcher expr; const internal::VariadicDynCastAllOfMatcher declRefExpr; const internal::VariadicDynCastAllOfMatcher ifStmt; const internal::VariadicDynCastAllOfMatcher forStmt; const internal::VariadicDynCastAllOfMatcher cxxForRangeStmt; const internal::VariadicDynCastAllOfMatcher whileStmt; const internal::VariadicDynCastAllOfMatcher doStmt; const internal::VariadicDynCastAllOfMatcher breakStmt; const internal::VariadicDynCastAllOfMatcher continueStmt; const internal::VariadicDynCastAllOfMatcher returnStmt; const internal::VariadicDynCastAllOfMatcher gotoStmt; const internal::VariadicDynCastAllOfMatcher labelStmt; const internal::VariadicDynCastAllOfMatcher addrLabelExpr; const internal::VariadicDynCastAllOfMatcher switchStmt; const internal::VariadicDynCastAllOfMatcher switchCase; const internal::VariadicDynCastAllOfMatcher caseStmt; const internal::VariadicDynCastAllOfMatcher defaultStmt; const internal::VariadicDynCastAllOfMatcher compoundStmt; const internal::VariadicDynCastAllOfMatcher cxxCatchStmt; const internal::VariadicDynCastAllOfMatcher cxxTryStmt; const internal::VariadicDynCastAllOfMatcher cxxThrowExpr; const internal::VariadicDynCastAllOfMatcher nullStmt; const internal::VariadicDynCastAllOfMatcher asmStmt; const internal::VariadicDynCastAllOfMatcher cxxBoolLiteral; const internal::VariadicDynCastAllOfMatcher stringLiteral; const internal::VariadicDynCastAllOfMatcher characterLiteral; const internal::VariadicDynCastAllOfMatcher integerLiteral; const internal::VariadicDynCastAllOfMatcher floatLiteral; const internal::VariadicDynCastAllOfMatcher userDefinedLiteral; const internal::VariadicDynCastAllOfMatcher compoundLiteralExpr; const internal::VariadicDynCastAllOfMatcher cxxNullPtrLiteralExpr; const internal::VariadicDynCastAllOfMatcher gnuNullExpr; const internal::VariadicDynCastAllOfMatcher atomicExpr; const internal::VariadicDynCastAllOfMatcher stmtExpr; const internal::VariadicDynCastAllOfMatcher binaryOperator; const internal::VariadicDynCastAllOfMatcher unaryOperator; const internal::VariadicDynCastAllOfMatcher conditionalOperator; const internal::VariadicDynCastAllOfMatcher binaryConditionalOperator; const internal::VariadicDynCastAllOfMatcher opaqueValueExpr; const internal::VariadicDynCastAllOfMatcher staticAssertDecl; const internal::VariadicDynCastAllOfMatcher cxxReinterpretCastExpr; const internal::VariadicDynCastAllOfMatcher cxxStaticCastExpr; const internal::VariadicDynCastAllOfMatcher cxxDynamicCastExpr; const internal::VariadicDynCastAllOfMatcher cxxConstCastExpr; const internal::VariadicDynCastAllOfMatcher cStyleCastExpr; const internal::VariadicDynCastAllOfMatcher explicitCastExpr; const internal::VariadicDynCastAllOfMatcher implicitCastExpr; const internal::VariadicDynCastAllOfMatcher castExpr; const internal::VariadicDynCastAllOfMatcher cxxFunctionalCastExpr; const internal::VariadicDynCastAllOfMatcher cxxTemporaryObjectExpr; const internal::VariadicDynCastAllOfMatcher predefinedExpr; const internal::VariadicDynCastAllOfMatcher designatedInitExpr; const internal::VariadicOperatorMatcherFunc< 2, std::numeric_limits::max()> eachOf = {internal::DynTypedMatcher::VO_EachOf}; const internal::VariadicOperatorMatcherFunc< 2, std::numeric_limits::max()> anyOf = {internal::DynTypedMatcher::VO_AnyOf}; const internal::VariadicOperatorMatcherFunc< 2, std::numeric_limits::max()> allOf = {internal::DynTypedMatcher::VO_AllOf}; const internal::VariadicFunction, StringRef, internal::hasAnyNameFunc> hasAnyName = {}; const internal::VariadicFunction, StringRef, internal::hasAnySelectorFunc> hasAnySelector = {}; const internal::ArgumentAdaptingMatcherFunc has = {}; const internal::ArgumentAdaptingMatcherFunc hasDescendant = {}; const internal::ArgumentAdaptingMatcherFunc forEach = {}; const internal::ArgumentAdaptingMatcherFunc forEachDescendant = {}; const internal::ArgumentAdaptingMatcherFunc< internal::HasParentMatcher, internal::TypeList, internal::TypeList> hasParent = {}; const internal::ArgumentAdaptingMatcherFunc< internal::HasAncestorMatcher, internal::TypeList, internal::TypeList> hasAncestor = {}; const internal::VariadicOperatorMatcherFunc<1, 1> unless = { internal::DynTypedMatcher::VO_UnaryNot}; const internal::VariadicAllOfMatcher nestedNameSpecifier; const internal::VariadicAllOfMatcher nestedNameSpecifierLoc; const internal::VariadicDynCastAllOfMatcher cudaKernelCallExpr; const AstTypeMatcher builtinType; const AstTypeMatcher arrayType; const AstTypeMatcher complexType; const AstTypeMatcher constantArrayType; const AstTypeMatcher dependentSizedArrayType; const AstTypeMatcher incompleteArrayType; const AstTypeMatcher variableArrayType; const AstTypeMatcher atomicType; const AstTypeMatcher autoType; const AstTypeMatcher functionType; const AstTypeMatcher functionProtoType; const AstTypeMatcher parenType; const AstTypeMatcher blockPointerType; const AstTypeMatcher memberPointerType; const AstTypeMatcher pointerType; const AstTypeMatcher objcObjectPointerType; const AstTypeMatcher referenceType; const AstTypeMatcher lValueReferenceType; const AstTypeMatcher rValueReferenceType; const AstTypeMatcher typedefType; const AstTypeMatcher enumType; const AstTypeMatcher templateSpecializationType; const AstTypeMatcher unaryTransformType; const AstTypeMatcher recordType; const AstTypeMatcher tagType; const AstTypeMatcher elaboratedType; const AstTypeMatcher substTemplateTypeParmType; const AstTypeMatcher templateTypeParmType; const AstTypeMatcher injectedClassNameType; const AstTypeMatcher decayedType; AST_TYPELOC_TRAVERSE_MATCHER_DEF(hasElementType, AST_POLYMORPHIC_SUPPORTED_TYPES(ArrayType, ComplexType)); AST_TYPELOC_TRAVERSE_MATCHER_DEF(hasValueType, AST_POLYMORPHIC_SUPPORTED_TYPES(AtomicType)); AST_TYPELOC_TRAVERSE_MATCHER_DEF( pointee, AST_POLYMORPHIC_SUPPORTED_TYPES(BlockPointerType, MemberPointerType, PointerType, ReferenceType)); @ 1.1.1.5.14.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.5.12.1 log @Sync with HEAD @ text @d1 1 a1 1 //===- ASTMatchersInternal.cpp - Structural query framework ---------------===// d14 1 a15 10 #include "clang/AST/ASTContext.h" #include "clang/AST/ASTTypeTraits.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/PrettyPrinter.h" #include "clang/ASTMatchers/ASTMatchers.h" #include "clang/Basic/LLVM.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/IntrusiveRefCntPtr.h" #include "llvm/ADT/None.h" a17 3 #include "llvm/ADT/StringRef.h" #include "llvm/Support/Casting.h" #include "llvm/Support/ErrorHandling.h" a18 7 #include "llvm/Support/raw_ostream.h" #include #include #include #include #include #include a21 10 AST_MATCHER_P(ObjCMessageExpr, hasAnySelectorMatcher, std::vector, Matches) { std::string SelString = Node.getSelector().getAsString(); for (const std::string &S : Matches) if (S == SelString) return true; return false; } d43 1 d54 1 a54 1 using VariadicOperatorFunction = bool (*)( d93 1 a93 1 /// A matcher that always returns true. a102 1 d108 1 d110 1 a110 3 } // namespace static llvm::ManagedStatic TrueMatcherInstance; d116 1 a116 1 assert(!InnerMatchers.empty() && "Array must not be empty."); d298 1 a298 2 inline static std::vector vectorFromRefs(ArrayRef NameRefs) { d302 2 a303 11 return Names; } Matcher hasAnyNameFunc(ArrayRef NameRefs) { std::vector Names = vectorFromRefs(NameRefs); return internal::Matcher(new internal::HasNameMatcher(Names)); } Matcher hasAnySelectorFunc( ArrayRef NameRefs) { return hasAnySelectorMatcher(vectorFromRefs(NameRefs)); d317 3 a319 1 static bool consumeNameSuffix(StringRef &FullName, StringRef Suffix) { d333 1 a333 2 static StringRef getNodeName(const NamedDecl &Node, llvm::SmallString<128> &Scratch) { d349 1 a349 2 static StringRef getNodeName(const RecordDecl &Node, llvm::SmallString<128> &Scratch) { d357 2 a358 2 static StringRef getNodeName(const NamespaceDecl &Node, llvm::SmallString<128> &Scratch) { a361 1 namespace { d375 1 a375 2 if (::clang::ast_matchers::internal::consumeNameSuffix(Patterns[I].P, NodeName) || a399 1 d403 1 a403 1 } // namespace a506 284 const internal::VariadicDynCastAllOfMatcher autoreleasePoolStmt; const internal::VariadicDynCastAllOfMatcher translationUnitDecl; const internal::VariadicDynCastAllOfMatcher typedefDecl; const internal::VariadicDynCastAllOfMatcher typedefNameDecl; const internal::VariadicDynCastAllOfMatcher typeAliasDecl; const internal::VariadicDynCastAllOfMatcher typeAliasTemplateDecl; const internal::VariadicAllOfMatcher decl; const internal::VariadicDynCastAllOfMatcher linkageSpecDecl; const internal::VariadicDynCastAllOfMatcher namedDecl; const internal::VariadicDynCastAllOfMatcher labelDecl; const internal::VariadicDynCastAllOfMatcher namespaceDecl; const internal::VariadicDynCastAllOfMatcher namespaceAliasDecl; const internal::VariadicDynCastAllOfMatcher recordDecl; const internal::VariadicDynCastAllOfMatcher cxxRecordDecl; const internal::VariadicDynCastAllOfMatcher classTemplateDecl; const internal::VariadicDynCastAllOfMatcher classTemplateSpecializationDecl; const internal::VariadicDynCastAllOfMatcher declaratorDecl; const internal::VariadicDynCastAllOfMatcher parmVarDecl; const internal::VariadicDynCastAllOfMatcher accessSpecDecl; const internal::VariadicAllOfMatcher cxxCtorInitializer; const internal::VariadicAllOfMatcher templateArgument; const internal::VariadicAllOfMatcher templateName; const internal::VariadicDynCastAllOfMatcher nonTypeTemplateParmDecl; const internal::VariadicDynCastAllOfMatcher templateTypeParmDecl; const internal::VariadicAllOfMatcher qualType; const internal::VariadicAllOfMatcher type; const internal::VariadicAllOfMatcher typeLoc; const internal::VariadicDynCastAllOfMatcher unaryExprOrTypeTraitExpr; const internal::VariadicDynCastAllOfMatcher valueDecl; const internal::VariadicDynCastAllOfMatcher cxxConstructorDecl; const internal::VariadicDynCastAllOfMatcher cxxDestructorDecl; const internal::VariadicDynCastAllOfMatcher enumDecl; const internal::VariadicDynCastAllOfMatcher enumConstantDecl; const internal::VariadicDynCastAllOfMatcher cxxMethodDecl; const internal::VariadicDynCastAllOfMatcher cxxConversionDecl; const internal::VariadicDynCastAllOfMatcher varDecl; const internal::VariadicDynCastAllOfMatcher fieldDecl; const internal::VariadicDynCastAllOfMatcher functionDecl; const internal::VariadicDynCastAllOfMatcher functionTemplateDecl; const internal::VariadicDynCastAllOfMatcher friendDecl; const internal::VariadicAllOfMatcher stmt; const internal::VariadicDynCastAllOfMatcher declStmt; const internal::VariadicDynCastAllOfMatcher memberExpr; const internal::VariadicDynCastAllOfMatcher callExpr; const internal::VariadicDynCastAllOfMatcher lambdaExpr; const internal::VariadicDynCastAllOfMatcher cxxMemberCallExpr; const internal::VariadicDynCastAllOfMatcher objcMessageExpr; const internal::VariadicDynCastAllOfMatcher objcInterfaceDecl; const internal::VariadicDynCastAllOfMatcher objcImplementationDecl; const internal::VariadicDynCastAllOfMatcher objcProtocolDecl; const internal::VariadicDynCastAllOfMatcher objcCategoryDecl; const internal::VariadicDynCastAllOfMatcher objcCategoryImplDecl; const internal::VariadicDynCastAllOfMatcher objcMethodDecl; const internal::VariadicDynCastAllOfMatcher blockDecl; const internal::VariadicDynCastAllOfMatcher objcIvarDecl; const internal::VariadicDynCastAllOfMatcher objcPropertyDecl; const internal::VariadicDynCastAllOfMatcher objcThrowStmt; const internal::VariadicDynCastAllOfMatcher objcTryStmt; const internal::VariadicDynCastAllOfMatcher objcCatchStmt; const internal::VariadicDynCastAllOfMatcher objcFinallyStmt; const internal::VariadicDynCastAllOfMatcher exprWithCleanups; const internal::VariadicDynCastAllOfMatcher initListExpr; const internal::VariadicDynCastAllOfMatcher cxxStdInitializerListExpr; const internal::VariadicDynCastAllOfMatcher implicitValueInitExpr; const internal::VariadicDynCastAllOfMatcher parenListExpr; const internal::VariadicDynCastAllOfMatcher substNonTypeTemplateParmExpr; const internal::VariadicDynCastAllOfMatcher usingDecl; const internal::VariadicDynCastAllOfMatcher usingDirectiveDecl; const internal::VariadicDynCastAllOfMatcher unresolvedLookupExpr; const internal::VariadicDynCastAllOfMatcher unresolvedUsingValueDecl; const internal::VariadicDynCastAllOfMatcher unresolvedUsingTypenameDecl; const internal::VariadicDynCastAllOfMatcher parenExpr; const internal::VariadicDynCastAllOfMatcher cxxConstructExpr; const internal::VariadicDynCastAllOfMatcher cxxUnresolvedConstructExpr; const internal::VariadicDynCastAllOfMatcher cxxThisExpr; const internal::VariadicDynCastAllOfMatcher cxxBindTemporaryExpr; const internal::VariadicDynCastAllOfMatcher materializeTemporaryExpr; const internal::VariadicDynCastAllOfMatcher cxxNewExpr; const internal::VariadicDynCastAllOfMatcher cxxDeleteExpr; const internal::VariadicDynCastAllOfMatcher arraySubscriptExpr; const internal::VariadicDynCastAllOfMatcher cxxDefaultArgExpr; const internal::VariadicDynCastAllOfMatcher cxxOperatorCallExpr; const internal::VariadicDynCastAllOfMatcher expr; const internal::VariadicDynCastAllOfMatcher declRefExpr; const internal::VariadicDynCastAllOfMatcher ifStmt; const internal::VariadicDynCastAllOfMatcher forStmt; const internal::VariadicDynCastAllOfMatcher cxxForRangeStmt; const internal::VariadicDynCastAllOfMatcher whileStmt; const internal::VariadicDynCastAllOfMatcher doStmt; const internal::VariadicDynCastAllOfMatcher breakStmt; const internal::VariadicDynCastAllOfMatcher continueStmt; const internal::VariadicDynCastAllOfMatcher returnStmt; const internal::VariadicDynCastAllOfMatcher gotoStmt; const internal::VariadicDynCastAllOfMatcher labelStmt; const internal::VariadicDynCastAllOfMatcher addrLabelExpr; const internal::VariadicDynCastAllOfMatcher switchStmt; const internal::VariadicDynCastAllOfMatcher switchCase; const internal::VariadicDynCastAllOfMatcher caseStmt; const internal::VariadicDynCastAllOfMatcher defaultStmt; const internal::VariadicDynCastAllOfMatcher compoundStmt; const internal::VariadicDynCastAllOfMatcher cxxCatchStmt; const internal::VariadicDynCastAllOfMatcher cxxTryStmt; const internal::VariadicDynCastAllOfMatcher cxxThrowExpr; const internal::VariadicDynCastAllOfMatcher nullStmt; const internal::VariadicDynCastAllOfMatcher asmStmt; const internal::VariadicDynCastAllOfMatcher cxxBoolLiteral; const internal::VariadicDynCastAllOfMatcher stringLiteral; const internal::VariadicDynCastAllOfMatcher characterLiteral; const internal::VariadicDynCastAllOfMatcher integerLiteral; const internal::VariadicDynCastAllOfMatcher floatLiteral; const internal::VariadicDynCastAllOfMatcher userDefinedLiteral; const internal::VariadicDynCastAllOfMatcher compoundLiteralExpr; const internal::VariadicDynCastAllOfMatcher cxxNullPtrLiteralExpr; const internal::VariadicDynCastAllOfMatcher gnuNullExpr; const internal::VariadicDynCastAllOfMatcher atomicExpr; const internal::VariadicDynCastAllOfMatcher stmtExpr; const internal::VariadicDynCastAllOfMatcher binaryOperator; const internal::VariadicDynCastAllOfMatcher unaryOperator; const internal::VariadicDynCastAllOfMatcher conditionalOperator; const internal::VariadicDynCastAllOfMatcher binaryConditionalOperator; const internal::VariadicDynCastAllOfMatcher opaqueValueExpr; const internal::VariadicDynCastAllOfMatcher staticAssertDecl; const internal::VariadicDynCastAllOfMatcher cxxReinterpretCastExpr; const internal::VariadicDynCastAllOfMatcher cxxStaticCastExpr; const internal::VariadicDynCastAllOfMatcher cxxDynamicCastExpr; const internal::VariadicDynCastAllOfMatcher cxxConstCastExpr; const internal::VariadicDynCastAllOfMatcher cStyleCastExpr; const internal::VariadicDynCastAllOfMatcher explicitCastExpr; const internal::VariadicDynCastAllOfMatcher implicitCastExpr; const internal::VariadicDynCastAllOfMatcher castExpr; const internal::VariadicDynCastAllOfMatcher cxxFunctionalCastExpr; const internal::VariadicDynCastAllOfMatcher cxxTemporaryObjectExpr; const internal::VariadicDynCastAllOfMatcher predefinedExpr; const internal::VariadicDynCastAllOfMatcher designatedInitExpr; const internal::VariadicOperatorMatcherFunc< 2, std::numeric_limits::max()> eachOf = {internal::DynTypedMatcher::VO_EachOf}; const internal::VariadicOperatorMatcherFunc< 2, std::numeric_limits::max()> anyOf = {internal::DynTypedMatcher::VO_AnyOf}; const internal::VariadicOperatorMatcherFunc< 2, std::numeric_limits::max()> allOf = {internal::DynTypedMatcher::VO_AllOf}; const internal::VariadicFunction, StringRef, internal::hasAnyNameFunc> hasAnyName = {}; const internal::VariadicFunction, StringRef, internal::hasAnySelectorFunc> hasAnySelector = {}; const internal::ArgumentAdaptingMatcherFunc has = {}; const internal::ArgumentAdaptingMatcherFunc hasDescendant = {}; const internal::ArgumentAdaptingMatcherFunc forEach = {}; const internal::ArgumentAdaptingMatcherFunc forEachDescendant = {}; const internal::ArgumentAdaptingMatcherFunc< internal::HasParentMatcher, internal::TypeList, internal::TypeList> hasParent = {}; const internal::ArgumentAdaptingMatcherFunc< internal::HasAncestorMatcher, internal::TypeList, internal::TypeList> hasAncestor = {}; const internal::VariadicOperatorMatcherFunc<1, 1> unless = { internal::DynTypedMatcher::VO_UnaryNot}; const internal::VariadicAllOfMatcher nestedNameSpecifier; const internal::VariadicAllOfMatcher nestedNameSpecifierLoc; const internal::VariadicDynCastAllOfMatcher cudaKernelCallExpr; const AstTypeMatcher builtinType; const AstTypeMatcher arrayType; const AstTypeMatcher complexType; const AstTypeMatcher constantArrayType; const AstTypeMatcher dependentSizedArrayType; const AstTypeMatcher incompleteArrayType; const AstTypeMatcher variableArrayType; const AstTypeMatcher atomicType; const AstTypeMatcher autoType; const AstTypeMatcher functionType; const AstTypeMatcher functionProtoType; const AstTypeMatcher parenType; const AstTypeMatcher blockPointerType; const AstTypeMatcher memberPointerType; const AstTypeMatcher pointerType; const AstTypeMatcher objcObjectPointerType; const AstTypeMatcher referenceType; const AstTypeMatcher lValueReferenceType; const AstTypeMatcher rValueReferenceType; const AstTypeMatcher typedefType; const AstTypeMatcher enumType; const AstTypeMatcher templateSpecializationType; const AstTypeMatcher unaryTransformType; const AstTypeMatcher recordType; const AstTypeMatcher tagType; const AstTypeMatcher elaboratedType; const AstTypeMatcher substTemplateTypeParmType; const AstTypeMatcher templateTypeParmType; const AstTypeMatcher injectedClassNameType; const AstTypeMatcher decayedType; AST_TYPELOC_TRAVERSE_MATCHER_DEF(hasElementType, AST_POLYMORPHIC_SUPPORTED_TYPES(ArrayType, ComplexType)); AST_TYPELOC_TRAVERSE_MATCHER_DEF(hasValueType, AST_POLYMORPHIC_SUPPORTED_TYPES(AtomicType)); AST_TYPELOC_TRAVERSE_MATCHER_DEF( pointee, AST_POLYMORPHIC_SUPPORTED_TYPES(BlockPointerType, MemberPointerType, PointerType, ReferenceType)); @ 1.1.1.6 log @Import clang r337282 from trunk @ text @d1 1 a1 1 //===- ASTMatchersInternal.cpp - Structural query framework ---------------===// d14 1 a15 10 #include "clang/AST/ASTContext.h" #include "clang/AST/ASTTypeTraits.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/PrettyPrinter.h" #include "clang/ASTMatchers/ASTMatchers.h" #include "clang/Basic/LLVM.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/IntrusiveRefCntPtr.h" #include "llvm/ADT/None.h" a17 3 #include "llvm/ADT/StringRef.h" #include "llvm/Support/Casting.h" #include "llvm/Support/ErrorHandling.h" a18 7 #include "llvm/Support/raw_ostream.h" #include #include #include #include #include #include a21 10 AST_MATCHER_P(ObjCMessageExpr, hasAnySelectorMatcher, std::vector, Matches) { std::string SelString = Node.getSelector().getAsString(); for (const std::string &S : Matches) if (S == SelString) return true; return false; } d43 1 d54 1 a54 1 using VariadicOperatorFunction = bool (*)( d93 1 a93 1 /// A matcher that always returns true. a102 1 d108 1 d110 1 a110 3 } // namespace static llvm::ManagedStatic TrueMatcherInstance; d116 1 a116 1 assert(!InnerMatchers.empty() && "Array must not be empty."); d298 1 a298 2 inline static std::vector vectorFromRefs(ArrayRef NameRefs) { d302 2 a303 11 return Names; } Matcher hasAnyNameFunc(ArrayRef NameRefs) { std::vector Names = vectorFromRefs(NameRefs); return internal::Matcher(new internal::HasNameMatcher(Names)); } Matcher hasAnySelectorFunc( ArrayRef NameRefs) { return hasAnySelectorMatcher(vectorFromRefs(NameRefs)); d317 3 a319 1 static bool consumeNameSuffix(StringRef &FullName, StringRef Suffix) { d333 1 a333 2 static StringRef getNodeName(const NamedDecl &Node, llvm::SmallString<128> &Scratch) { d349 1 a349 2 static StringRef getNodeName(const RecordDecl &Node, llvm::SmallString<128> &Scratch) { d357 2 a358 2 static StringRef getNodeName(const NamespaceDecl &Node, llvm::SmallString<128> &Scratch) { a361 1 namespace { d375 1 a375 2 if (::clang::ast_matchers::internal::consumeNameSuffix(Patterns[I].P, NodeName) || a399 1 d403 1 a403 1 } // namespace a506 284 const internal::VariadicDynCastAllOfMatcher autoreleasePoolStmt; const internal::VariadicDynCastAllOfMatcher translationUnitDecl; const internal::VariadicDynCastAllOfMatcher typedefDecl; const internal::VariadicDynCastAllOfMatcher typedefNameDecl; const internal::VariadicDynCastAllOfMatcher typeAliasDecl; const internal::VariadicDynCastAllOfMatcher typeAliasTemplateDecl; const internal::VariadicAllOfMatcher decl; const internal::VariadicDynCastAllOfMatcher linkageSpecDecl; const internal::VariadicDynCastAllOfMatcher namedDecl; const internal::VariadicDynCastAllOfMatcher labelDecl; const internal::VariadicDynCastAllOfMatcher namespaceDecl; const internal::VariadicDynCastAllOfMatcher namespaceAliasDecl; const internal::VariadicDynCastAllOfMatcher recordDecl; const internal::VariadicDynCastAllOfMatcher cxxRecordDecl; const internal::VariadicDynCastAllOfMatcher classTemplateDecl; const internal::VariadicDynCastAllOfMatcher classTemplateSpecializationDecl; const internal::VariadicDynCastAllOfMatcher declaratorDecl; const internal::VariadicDynCastAllOfMatcher parmVarDecl; const internal::VariadicDynCastAllOfMatcher accessSpecDecl; const internal::VariadicAllOfMatcher cxxCtorInitializer; const internal::VariadicAllOfMatcher templateArgument; const internal::VariadicAllOfMatcher templateName; const internal::VariadicDynCastAllOfMatcher nonTypeTemplateParmDecl; const internal::VariadicDynCastAllOfMatcher templateTypeParmDecl; const internal::VariadicAllOfMatcher qualType; const internal::VariadicAllOfMatcher type; const internal::VariadicAllOfMatcher typeLoc; const internal::VariadicDynCastAllOfMatcher unaryExprOrTypeTraitExpr; const internal::VariadicDynCastAllOfMatcher valueDecl; const internal::VariadicDynCastAllOfMatcher cxxConstructorDecl; const internal::VariadicDynCastAllOfMatcher cxxDestructorDecl; const internal::VariadicDynCastAllOfMatcher enumDecl; const internal::VariadicDynCastAllOfMatcher enumConstantDecl; const internal::VariadicDynCastAllOfMatcher cxxMethodDecl; const internal::VariadicDynCastAllOfMatcher cxxConversionDecl; const internal::VariadicDynCastAllOfMatcher varDecl; const internal::VariadicDynCastAllOfMatcher fieldDecl; const internal::VariadicDynCastAllOfMatcher functionDecl; const internal::VariadicDynCastAllOfMatcher functionTemplateDecl; const internal::VariadicDynCastAllOfMatcher friendDecl; const internal::VariadicAllOfMatcher stmt; const internal::VariadicDynCastAllOfMatcher declStmt; const internal::VariadicDynCastAllOfMatcher memberExpr; const internal::VariadicDynCastAllOfMatcher callExpr; const internal::VariadicDynCastAllOfMatcher lambdaExpr; const internal::VariadicDynCastAllOfMatcher cxxMemberCallExpr; const internal::VariadicDynCastAllOfMatcher objcMessageExpr; const internal::VariadicDynCastAllOfMatcher objcInterfaceDecl; const internal::VariadicDynCastAllOfMatcher objcImplementationDecl; const internal::VariadicDynCastAllOfMatcher objcProtocolDecl; const internal::VariadicDynCastAllOfMatcher objcCategoryDecl; const internal::VariadicDynCastAllOfMatcher objcCategoryImplDecl; const internal::VariadicDynCastAllOfMatcher objcMethodDecl; const internal::VariadicDynCastAllOfMatcher blockDecl; const internal::VariadicDynCastAllOfMatcher objcIvarDecl; const internal::VariadicDynCastAllOfMatcher objcPropertyDecl; const internal::VariadicDynCastAllOfMatcher objcThrowStmt; const internal::VariadicDynCastAllOfMatcher objcTryStmt; const internal::VariadicDynCastAllOfMatcher objcCatchStmt; const internal::VariadicDynCastAllOfMatcher objcFinallyStmt; const internal::VariadicDynCastAllOfMatcher exprWithCleanups; const internal::VariadicDynCastAllOfMatcher initListExpr; const internal::VariadicDynCastAllOfMatcher cxxStdInitializerListExpr; const internal::VariadicDynCastAllOfMatcher implicitValueInitExpr; const internal::VariadicDynCastAllOfMatcher parenListExpr; const internal::VariadicDynCastAllOfMatcher substNonTypeTemplateParmExpr; const internal::VariadicDynCastAllOfMatcher usingDecl; const internal::VariadicDynCastAllOfMatcher usingDirectiveDecl; const internal::VariadicDynCastAllOfMatcher unresolvedLookupExpr; const internal::VariadicDynCastAllOfMatcher unresolvedUsingValueDecl; const internal::VariadicDynCastAllOfMatcher unresolvedUsingTypenameDecl; const internal::VariadicDynCastAllOfMatcher parenExpr; const internal::VariadicDynCastAllOfMatcher cxxConstructExpr; const internal::VariadicDynCastAllOfMatcher cxxUnresolvedConstructExpr; const internal::VariadicDynCastAllOfMatcher cxxThisExpr; const internal::VariadicDynCastAllOfMatcher cxxBindTemporaryExpr; const internal::VariadicDynCastAllOfMatcher materializeTemporaryExpr; const internal::VariadicDynCastAllOfMatcher cxxNewExpr; const internal::VariadicDynCastAllOfMatcher cxxDeleteExpr; const internal::VariadicDynCastAllOfMatcher arraySubscriptExpr; const internal::VariadicDynCastAllOfMatcher cxxDefaultArgExpr; const internal::VariadicDynCastAllOfMatcher cxxOperatorCallExpr; const internal::VariadicDynCastAllOfMatcher expr; const internal::VariadicDynCastAllOfMatcher declRefExpr; const internal::VariadicDynCastAllOfMatcher ifStmt; const internal::VariadicDynCastAllOfMatcher forStmt; const internal::VariadicDynCastAllOfMatcher cxxForRangeStmt; const internal::VariadicDynCastAllOfMatcher whileStmt; const internal::VariadicDynCastAllOfMatcher doStmt; const internal::VariadicDynCastAllOfMatcher breakStmt; const internal::VariadicDynCastAllOfMatcher continueStmt; const internal::VariadicDynCastAllOfMatcher returnStmt; const internal::VariadicDynCastAllOfMatcher gotoStmt; const internal::VariadicDynCastAllOfMatcher labelStmt; const internal::VariadicDynCastAllOfMatcher addrLabelExpr; const internal::VariadicDynCastAllOfMatcher switchStmt; const internal::VariadicDynCastAllOfMatcher switchCase; const internal::VariadicDynCastAllOfMatcher caseStmt; const internal::VariadicDynCastAllOfMatcher defaultStmt; const internal::VariadicDynCastAllOfMatcher compoundStmt; const internal::VariadicDynCastAllOfMatcher cxxCatchStmt; const internal::VariadicDynCastAllOfMatcher cxxTryStmt; const internal::VariadicDynCastAllOfMatcher cxxThrowExpr; const internal::VariadicDynCastAllOfMatcher nullStmt; const internal::VariadicDynCastAllOfMatcher asmStmt; const internal::VariadicDynCastAllOfMatcher cxxBoolLiteral; const internal::VariadicDynCastAllOfMatcher stringLiteral; const internal::VariadicDynCastAllOfMatcher characterLiteral; const internal::VariadicDynCastAllOfMatcher integerLiteral; const internal::VariadicDynCastAllOfMatcher floatLiteral; const internal::VariadicDynCastAllOfMatcher userDefinedLiteral; const internal::VariadicDynCastAllOfMatcher compoundLiteralExpr; const internal::VariadicDynCastAllOfMatcher cxxNullPtrLiteralExpr; const internal::VariadicDynCastAllOfMatcher gnuNullExpr; const internal::VariadicDynCastAllOfMatcher atomicExpr; const internal::VariadicDynCastAllOfMatcher stmtExpr; const internal::VariadicDynCastAllOfMatcher binaryOperator; const internal::VariadicDynCastAllOfMatcher unaryOperator; const internal::VariadicDynCastAllOfMatcher conditionalOperator; const internal::VariadicDynCastAllOfMatcher binaryConditionalOperator; const internal::VariadicDynCastAllOfMatcher opaqueValueExpr; const internal::VariadicDynCastAllOfMatcher staticAssertDecl; const internal::VariadicDynCastAllOfMatcher cxxReinterpretCastExpr; const internal::VariadicDynCastAllOfMatcher cxxStaticCastExpr; const internal::VariadicDynCastAllOfMatcher cxxDynamicCastExpr; const internal::VariadicDynCastAllOfMatcher cxxConstCastExpr; const internal::VariadicDynCastAllOfMatcher cStyleCastExpr; const internal::VariadicDynCastAllOfMatcher explicitCastExpr; const internal::VariadicDynCastAllOfMatcher implicitCastExpr; const internal::VariadicDynCastAllOfMatcher castExpr; const internal::VariadicDynCastAllOfMatcher cxxFunctionalCastExpr; const internal::VariadicDynCastAllOfMatcher cxxTemporaryObjectExpr; const internal::VariadicDynCastAllOfMatcher predefinedExpr; const internal::VariadicDynCastAllOfMatcher designatedInitExpr; const internal::VariadicOperatorMatcherFunc< 2, std::numeric_limits::max()> eachOf = {internal::DynTypedMatcher::VO_EachOf}; const internal::VariadicOperatorMatcherFunc< 2, std::numeric_limits::max()> anyOf = {internal::DynTypedMatcher::VO_AnyOf}; const internal::VariadicOperatorMatcherFunc< 2, std::numeric_limits::max()> allOf = {internal::DynTypedMatcher::VO_AllOf}; const internal::VariadicFunction, StringRef, internal::hasAnyNameFunc> hasAnyName = {}; const internal::VariadicFunction, StringRef, internal::hasAnySelectorFunc> hasAnySelector = {}; const internal::ArgumentAdaptingMatcherFunc has = {}; const internal::ArgumentAdaptingMatcherFunc hasDescendant = {}; const internal::ArgumentAdaptingMatcherFunc forEach = {}; const internal::ArgumentAdaptingMatcherFunc forEachDescendant = {}; const internal::ArgumentAdaptingMatcherFunc< internal::HasParentMatcher, internal::TypeList, internal::TypeList> hasParent = {}; const internal::ArgumentAdaptingMatcherFunc< internal::HasAncestorMatcher, internal::TypeList, internal::TypeList> hasAncestor = {}; const internal::VariadicOperatorMatcherFunc<1, 1> unless = { internal::DynTypedMatcher::VO_UnaryNot}; const internal::VariadicAllOfMatcher nestedNameSpecifier; const internal::VariadicAllOfMatcher nestedNameSpecifierLoc; const internal::VariadicDynCastAllOfMatcher cudaKernelCallExpr; const AstTypeMatcher builtinType; const AstTypeMatcher arrayType; const AstTypeMatcher complexType; const AstTypeMatcher constantArrayType; const AstTypeMatcher dependentSizedArrayType; const AstTypeMatcher incompleteArrayType; const AstTypeMatcher variableArrayType; const AstTypeMatcher atomicType; const AstTypeMatcher autoType; const AstTypeMatcher functionType; const AstTypeMatcher functionProtoType; const AstTypeMatcher parenType; const AstTypeMatcher blockPointerType; const AstTypeMatcher memberPointerType; const AstTypeMatcher pointerType; const AstTypeMatcher objcObjectPointerType; const AstTypeMatcher referenceType; const AstTypeMatcher lValueReferenceType; const AstTypeMatcher rValueReferenceType; const AstTypeMatcher typedefType; const AstTypeMatcher enumType; const AstTypeMatcher templateSpecializationType; const AstTypeMatcher unaryTransformType; const AstTypeMatcher recordType; const AstTypeMatcher tagType; const AstTypeMatcher elaboratedType; const AstTypeMatcher substTemplateTypeParmType; const AstTypeMatcher templateTypeParmType; const AstTypeMatcher injectedClassNameType; const AstTypeMatcher decayedType; AST_TYPELOC_TRAVERSE_MATCHER_DEF(hasElementType, AST_POLYMORPHIC_SUPPORTED_TYPES(ArrayType, ComplexType)); AST_TYPELOC_TRAVERSE_MATCHER_DEF(hasValueType, AST_POLYMORPHIC_SUPPORTED_TYPES(AtomicType)); AST_TYPELOC_TRAVERSE_MATCHER_DEF( pointee, AST_POLYMORPHIC_SUPPORTED_TYPES(BlockPointerType, MemberPointerType, PointerType, ReferenceType)); @ 1.1.1.7 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.2.8.1 log @file ASTMatchersInternal.cpp was added on branch tls-maxphys on 2014-08-19 23:47:26 +0000 @ text @d1 104 @ 1.1.1.2.8.2 log @Rebase to HEAD as of a few days ago. @ text @a0 104 //===--- ASTMatchersInternal.cpp - Structural query framework -------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // Implements the base layer of the matcher framework. // //===----------------------------------------------------------------------===// #include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchersInternal.h" namespace clang { namespace ast_matchers { namespace internal { void BoundNodesTreeBuilder::visitMatches(Visitor *ResultVisitor) { if (Bindings.empty()) Bindings.push_back(BoundNodesMap()); for (unsigned i = 0, e = Bindings.size(); i != e; ++i) { ResultVisitor->visitMatch(BoundNodes(Bindings[i])); } } DynTypedMatcher::MatcherStorage::~MatcherStorage() {} void BoundNodesTreeBuilder::addMatch(const BoundNodesTreeBuilder &Other) { for (unsigned i = 0, e = Other.Bindings.size(); i != e; ++i) { Bindings.push_back(Other.Bindings[i]); } } bool NotUnaryOperator(const ast_type_traits::DynTypedNode DynNode, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder, ArrayRef InnerMatchers) { if (InnerMatchers.size() != 1) return false; // The 'unless' matcher will always discard the result: // If the inner matcher doesn't match, unless returns true, // but the inner matcher cannot have bound anything. // If the inner matcher matches, the result is false, and // any possible binding will be discarded. // We still need to hand in all the bound nodes up to this // point so the inner matcher can depend on bound nodes, // and we need to actively discard the bound nodes, otherwise // the inner matcher will reset the bound nodes if it doesn't // match, but this would be inversed by 'unless'. BoundNodesTreeBuilder Discard(*Builder); return !InnerMatchers[0].matches(DynNode, Finder, &Discard); } bool AllOfVariadicOperator(const ast_type_traits::DynTypedNode DynNode, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder, ArrayRef InnerMatchers) { // allOf leads to one matcher for each alternative in the first // matcher combined with each alternative in the second matcher. // Thus, we can reuse the same Builder. for (size_t i = 0, e = InnerMatchers.size(); i != e; ++i) { if (!InnerMatchers[i].matches(DynNode, Finder, Builder)) return false; } return true; } bool EachOfVariadicOperator(const ast_type_traits::DynTypedNode DynNode, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder, ArrayRef InnerMatchers) { BoundNodesTreeBuilder Result; bool Matched = false; for (size_t i = 0, e = InnerMatchers.size(); i != e; ++i) { BoundNodesTreeBuilder BuilderInner(*Builder); if (InnerMatchers[i].matches(DynNode, Finder, &BuilderInner)) { Matched = true; Result.addMatch(BuilderInner); } } *Builder = Result; return Matched; } bool AnyOfVariadicOperator(const ast_type_traits::DynTypedNode DynNode, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder, ArrayRef InnerMatchers) { for (size_t i = 0, e = InnerMatchers.size(); i != e; ++i) { BoundNodesTreeBuilder Result = *Builder; if (InnerMatchers[i].matches(DynNode, Finder, &Result)) { *Builder = Result; return true; } } return false; } } // end namespace internal } // end namespace ast_matchers } // end namespace clang @ 1.1.1.2.4.1 log @file ASTMatchersInternal.cpp was added on branch yamt-pagecache on 2014-05-22 16:18:26 +0000 @ text @d1 104 @ 1.1.1.2.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 104 //===--- ASTMatchersInternal.cpp - Structural query framework -------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // Implements the base layer of the matcher framework. // //===----------------------------------------------------------------------===// #include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchersInternal.h" namespace clang { namespace ast_matchers { namespace internal { void BoundNodesTreeBuilder::visitMatches(Visitor *ResultVisitor) { if (Bindings.empty()) Bindings.push_back(BoundNodesMap()); for (unsigned i = 0, e = Bindings.size(); i != e; ++i) { ResultVisitor->visitMatch(BoundNodes(Bindings[i])); } } DynTypedMatcher::MatcherStorage::~MatcherStorage() {} void BoundNodesTreeBuilder::addMatch(const BoundNodesTreeBuilder &Other) { for (unsigned i = 0, e = Other.Bindings.size(); i != e; ++i) { Bindings.push_back(Other.Bindings[i]); } } bool NotUnaryOperator(const ast_type_traits::DynTypedNode DynNode, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder, ArrayRef InnerMatchers) { if (InnerMatchers.size() != 1) return false; // The 'unless' matcher will always discard the result: // If the inner matcher doesn't match, unless returns true, // but the inner matcher cannot have bound anything. // If the inner matcher matches, the result is false, and // any possible binding will be discarded. // We still need to hand in all the bound nodes up to this // point so the inner matcher can depend on bound nodes, // and we need to actively discard the bound nodes, otherwise // the inner matcher will reset the bound nodes if it doesn't // match, but this would be inversed by 'unless'. BoundNodesTreeBuilder Discard(*Builder); return !InnerMatchers[0].matches(DynNode, Finder, &Discard); } bool AllOfVariadicOperator(const ast_type_traits::DynTypedNode DynNode, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder, ArrayRef InnerMatchers) { // allOf leads to one matcher for each alternative in the first // matcher combined with each alternative in the second matcher. // Thus, we can reuse the same Builder. for (size_t i = 0, e = InnerMatchers.size(); i != e; ++i) { if (!InnerMatchers[i].matches(DynNode, Finder, Builder)) return false; } return true; } bool EachOfVariadicOperator(const ast_type_traits::DynTypedNode DynNode, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder, ArrayRef InnerMatchers) { BoundNodesTreeBuilder Result; bool Matched = false; for (size_t i = 0, e = InnerMatchers.size(); i != e; ++i) { BoundNodesTreeBuilder BuilderInner(*Builder); if (InnerMatchers[i].matches(DynNode, Finder, &BuilderInner)) { Matched = true; Result.addMatch(BuilderInner); } } *Builder = Result; return Matched; } bool AnyOfVariadicOperator(const ast_type_traits::DynTypedNode DynNode, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder, ArrayRef InnerMatchers) { for (size_t i = 0, e = InnerMatchers.size(); i != e; ++i) { BoundNodesTreeBuilder Result = *Builder; if (InnerMatchers[i].matches(DynNode, Finder, &Result)) { *Builder = Result; return true; } } return false; } } // end namespace internal } // end namespace ast_matchers } // end namespace clang @