Add a way to tell MatchFinder not to visit template instantiations and implicit code.

[alexfh]

Summary

We need this desperately in clang-tidy. There's currently no way to
easily avoid matches of typeLocs in implicit code.

[djasper]

What's the status here?

[alexfh]

IIRC, Manuel expressed a concern offline that adding another way to configure matchers would make matchers more difficult to develop and use and will also add more complexities wrt dynamic matchers and tools like clang_query. I may be wrong or missing something, so it would be nice if Manuel answered himself. I remember us talking about different alternatives, but don't recall any idea that would work well with memoization etc.

One of the problems I was going to solve with this is avoid matching of typelocs, variables and expressions generated from range-based for loop and implicit assignment operators.

include/clang/ASTMatchers/ASTMatchFinder.h

struct MatchFinderOptions {
     struct Profiling {
       Profiling(llvm::StringMap<llvm::TimeRecord> &Records)
           : Records(Records) {}
 
       /// \brief Per bucket timing information.
       llvm::StringMap<llvm::TimeRecord> &Records;
     };
 
+    MatchFinderOptions()
+        : ShouldVisitImplicitCode(true),
+          ShouldVisitTemplateInstantiations(true) {}
+
     /// \brief Enables per-check timers.
     ///
     /// It prints a report after match.
     llvm::Optional<Profiling> CheckProfiling;
+
+    bool ShouldVisitImplicitCode;
+    bool ShouldVisitTemplateInstantiations;
   };
 
   MatchFinder(MatchFinderOptions Options = MatchFinderOptions());
   ~MatchFinder();
 
   /// \brief Adds a matcher to execute when running over the AST.
   ///
   /// Calls 'Action' with the BoundNodes on every match.

lib/ASTMatchers/ASTMatchFinder.cpp

public:
   typedef RecursiveASTVisitor<MatchChildASTVisitor> VisitorBase;
 
   // Creates an AST visitor that matches 'matcher' on all children or
   // descendants of a traversed node. max_depth is the maximum depth
   // to traverse: use 1 for matching the children and INT_MAX for
   // matching the descendants.
   MatchChildASTVisitor(const DynTypedMatcher *Matcher,
                        ASTMatchFinder *Finder,
+                       const MatchFinder::MatchFinderOptions &Options,
                        BoundNodesTreeBuilder *Builder,
                        int MaxDepth,
                        ASTMatchFinder::TraversalKind Traversal,
                        ASTMatchFinder::BindKind Bind)
       : Matcher(Matcher),
         Finder(Finder),
+        Options(Options),
         Builder(Builder),
         CurrentDepth(0),
         MaxDepth(MaxDepth),
         Traversal(Traversal),
         Bind(Bind),
         Matches(false) {}
 
   // Returns true if a match is found in the subtree rooted at the
bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS) {
     if (!NNS)
       return true;
     ScopedIncrement ScopedDepth(&CurrentDepth);
     if (!match(*NNS.getNestedNameSpecifier()))
       return false;
     return traverse(NNS);
   }
 
-  bool shouldVisitTemplateInstantiations() const { return true; }
-  bool shouldVisitImplicitCode() const { return true; }
+  bool shouldVisitTemplateInstantiations() const {
+    return Options.ShouldVisitTemplateInstantiations;
+  }
+  bool shouldVisitImplicitCode() const {
+    return Options.ShouldVisitImplicitCode;
+  }
   // Disables data recursion. We intercept Traverse* methods in the RAV, which
   // are not triggered during data recursion.
   bool shouldUseDataRecursionFor(clang::Stmt *S) const { return false; }
 
 private:
   // Used for updating the depth during traversal.
   struct ScopedIncrement {
     explicit ScopedIncrement(int *Depth) : Depth(Depth) { ++(*Depth); }
static_assert(IsBaseType<T>::value,
                   "traverse can only be instantiated with base type");
     if (!match(Node))
       return false;
     return baseTraverse(Node);
   }
 
   const DynTypedMatcher *const Matcher;
   ASTMatchFinder *const Finder;
+  const MatchFinder::MatchFinderOptions &Options;
   BoundNodesTreeBuilder *const Builder;
   BoundNodesTreeBuilder ResultBindings;
   int CurrentDepth;
   const int MaxDepth;
   const ASTMatchFinder::TraversalKind Traversal;
   const ASTMatchFinder::BindKind Bind;
   bool Matches;
 };
public:
   }
 
   // Matches children or descendants of 'Node' with 'BaseMatcher'.
   bool matchesRecursively(const ast_type_traits::DynTypedNode &Node,
                           const DynTypedMatcher &Matcher,
                           BoundNodesTreeBuilder *Builder, int MaxDepth,
                           TraversalKind Traversal, BindKind Bind) {
     MatchChildASTVisitor Visitor(
-      &Matcher, this, Builder, MaxDepth, Traversal, Bind);
+      &Matcher, this, Options, Builder, MaxDepth, Traversal, Bind);
     return Visitor.findMatch(Node);
   }
 
   bool classIsDerivedFrom(const CXXRecordDecl *Declaration,
                           const Matcher<NamedDecl> &Base,
                           BoundNodesTreeBuilder *Builder) override;
 
   // Implements ASTMatchFinder::matchesChildOf.
public:
 
   template <typename T> void match(const T &Node) {
     matchDispatch(&Node);
   }
 
   // Implements ASTMatchFinder::getASTContext.
   ASTContext &getASTContext() const override { return *ActiveASTContext; }
 
-  bool shouldVisitTemplateInstantiations() const { return true; }
-  bool shouldVisitImplicitCode() const { return true; }
+  bool shouldVisitTemplateInstantiations() const {
+    return Options.ShouldVisitTemplateInstantiations;
+  }
+  bool shouldVisitImplicitCode() const {
+    return Options.ShouldVisitImplicitCode;
+  }
   // Disables data recursion. We intercept Traverse* methods in the RAV, which
   // are not triggered during data recursion.
   bool shouldUseDataRecursionFor(clang::Stmt *S) const { return false; }
 
 private:
   class TimeBucketRegion {
   public:
     TimeBucketRegion() : Bucket(nullptr) {}