Change algorithms to return iterators

[steveire]

Summary

Make it possible to inspect the matched node, possibly to ignore it.

[aaron.ballman]

LGTM!

clang/include/clang/ASTMatchers/ASTMatchers.h

AST_POLYMORPHIC_MATCHER_P(
     hasAnyTemplateArgument,
     AST_POLYMORPHIC_SUPPORTED_TYPES(ClassTemplateSpecializationDecl,
                                     TemplateSpecializationType,
                                     FunctionDecl),
     internal::Matcher<TemplateArgument>, InnerMatcher) {
   ArrayRef<TemplateArgument> List =
       internal::getTemplateSpecializationArgs(Node);
   return matchesFirstInRange(InnerMatcher, List.begin(), List.end(), Finder,
-                             Builder);
+                             Builder) != List.end();
 }
 
 /// Causes all nested matchers to be matched with the specified traversal kind.
 ///
 /// Given
 /// \code
 ///   void foo()
 ///   {

 ///   class B { void member(); };
 /// \endcode
 ///
 /// \c cxxRecordDecl(hasMethod(hasName("func"))) matches the declaration of
 /// \c A but not \c B.
 AST_MATCHER_P(CXXRecordDecl, hasMethod, internal::Matcher<CXXMethodDecl>,
               InnerMatcher) {
   return matchesFirstInPointerRange(InnerMatcher, Node.method_begin(),
-                                    Node.method_end(), Finder, Builder);
+                                    Node.method_end(), Finder,
+                                    Builder) != Node.method_end();
 }
 
 /// Matches the generated class of lambda expressions.
 ///
 /// Given:
 /// \code
 ///   auto x = []{};
 /// \endcode

 ///   }
 /// \endcode
 /// unresolvedLookupExpr(hasAnyDeclaration(
 ///     functionTemplateDecl(hasName("foo"))))
 ///   matches \c foo in \c foo(t); but not \c bar in \c bar(t);
 AST_MATCHER_P(OverloadExpr, hasAnyDeclaration, internal::Matcher<Decl>,
               InnerMatcher) {
   return matchesFirstInPointerRange(InnerMatcher, Node.decls_begin(),
-                                    Node.decls_end(), Finder, Builder);
+                                    Node.decls_end(), Finder,
+                                    Builder) != Node.decls_end();
 }
 
 /// Matches the Decl of a DeclStmt which has a single declaration.
 ///
 /// Given
 /// \code
 ///   int a, b;
 ///   int c;

 /// \endcode
 /// cxxRecordDecl(has(cxxConstructorDecl(
 ///   hasAnyConstructorInitializer(anything())
 /// )))
 ///   record matches Foo, hasAnyConstructorInitializer matches foo_(1)
 AST_MATCHER_P(CXXConstructorDecl, hasAnyConstructorInitializer,
               internal::Matcher<CXXCtorInitializer>, InnerMatcher) {
   return matchesFirstInPointerRange(InnerMatcher, Node.init_begin(),
-                                    Node.init_end(), Finder, Builder);
+                                    Node.init_end(), Finder,
+                                    Builder) != Node.init_end();
 }
 
 /// Matches the field declaration of a constructor initializer.
 ///
 /// Given
 /// \code
 ///   struct Foo {
 ///     Foo() : foo_(1) { }

 /// matching y.
 AST_POLYMORPHIC_MATCHER_P(hasAnyParameter,
                           AST_POLYMORPHIC_SUPPORTED_TYPES(FunctionDecl,
                                                           ObjCMethodDecl,
                                                           BlockDecl),
                           internal::Matcher<ParmVarDecl>,
                           InnerMatcher) {
   return matchesFirstInPointerRange(InnerMatcher, Node.param_begin(),
-                                    Node.param_end(), Finder, Builder);
+                                    Node.param_end(), Finder,
+                                    Builder) != Node.param_end();
 }
 
 /// Matches \c FunctionDecls and \c FunctionProtoTypes that have a
 /// specific parameter count.
 ///
 /// Given
 /// \code
 ///   void f(int i) {}

 /// with compoundStmt()
 ///   matching '{}'
 AST_POLYMORPHIC_MATCHER_P(hasAnySubstatement,
                           AST_POLYMORPHIC_SUPPORTED_TYPES(CompoundStmt,
                                                           StmtExpr),
                           internal::Matcher<Stmt>, InnerMatcher) {
   const CompoundStmt *CS = CompoundStmtMatcher<NodeType>::get(Node);
   return CS && matchesFirstInPointerRange(InnerMatcher, CS->body_begin(),
-                                          CS->body_end(), Finder, Builder);
+                                          CS->body_end(), Finder,
+                                          Builder) != CS->body_end();
 }
 
 /// Checks that a compound statement contains a specific number of
 /// child statements.
 ///
 /// Example: Given
 /// \code
 ///   { for (;;) {} }

 ///   namespace X { void b(); }
 ///   using X::b;
 /// \endcode
 /// usingDecl(hasAnyUsingShadowDecl(hasName("b"))))
 ///   matches \code using X::b \endcode
 AST_MATCHER_P(UsingDecl, hasAnyUsingShadowDecl,
               internal::Matcher<UsingShadowDecl>, InnerMatcher) {
   return matchesFirstInPointerRange(InnerMatcher, Node.shadow_begin(),
-                                    Node.shadow_end(), Finder, Builder);
+                                    Node.shadow_end(), Finder,
+                                    Builder) != Node.shadow_end();
 }
 
 /// Matches a using shadow declaration where the target declaration is
 /// matched by the given matcher.
 ///
 /// Given
 /// \code
 ///   namespace X { int a; void b(); }

 /// \endcode
 ///
 /// ``ompExecutableDirective(hasAnyClause(anything()))`` matches
 /// ``omp parallel default(none)``.
 AST_MATCHER_P(OMPExecutableDirective, hasAnyClause,
               internal::Matcher<OMPClause>, InnerMatcher) {
   ArrayRef<OMPClause *> Clauses = Node.clauses();
   return matchesFirstInPointerRange(InnerMatcher, Clauses.begin(),
-                                    Clauses.end(), Finder, Builder);
+                                    Clauses.end(), Finder,
+                                    Builder) != Clauses.end();
 }
 
 /// Matches OpenMP ``default`` clause.
 ///
 /// Given
 ///
 /// \code
 ///   #pragma omp parallel default(none)

clang/include/clang/ASTMatchers/ASTMatchersInternal.h

if (SourceKind.isSame(ASTNodeKind::getFromNodeKind<Type>())) {
     // We support implicit conversion from Matcher<Type> to Matcher<QualType>
     return unconditionalConvertTo<Type>();
   }
   return unconditionalConvertTo<QualType>();
 }
 
 /// Finds the first node in a range that matches the given matcher.
 template <typename MatcherT, typename IteratorT>
-bool matchesFirstInRange(const MatcherT &Matcher, IteratorT Start,
+IteratorT matchesFirstInRange(const MatcherT &Matcher, IteratorT Start,
                               IteratorT End, ASTMatchFinder *Finder,
                               BoundNodesTreeBuilder *Builder) {
   for (IteratorT I = Start; I != End; ++I) {
     BoundNodesTreeBuilder Result(*Builder);
     if (Matcher.matches(*I, Finder, &Result)) {
       *Builder = std::move(Result);
-      return true;
+      return I;
     }
   }
-  return false;
+  return End;
 }
 
 /// Finds the first node in a pointer range that matches the given
 /// matcher.
 template <typename MatcherT, typename IteratorT>
-bool matchesFirstInPointerRange(const MatcherT &Matcher, IteratorT Start,
+IteratorT matchesFirstInPointerRange(const MatcherT &Matcher, IteratorT Start,
                                      IteratorT End, ASTMatchFinder *Finder,
                                      BoundNodesTreeBuilder *Builder) {
   for (IteratorT I = Start; I != End; ++I) {
     BoundNodesTreeBuilder Result(*Builder);
     if (Matcher.matches(**I, Finder, &Result)) {
       *Builder = std::move(Result);
-      return true;
+      return I;
     }
   }
-  return false;
+  return End;
 }
 
 // Metafunction to determine if type T has a member called getDecl.
 template <typename Ty>
 class has_getDecl {
   using yes = char[1];
   using no = char[2];