Add utility for testing if we're matching nodes AsIs

[aaron.ballman]

LGTM, thanks!

clang/lib/ASTMatchers/ASTMatchersInternal.cpp

195

I don't insist, but I do wonder if we want to inline the definition in the header file rather than put it in the implementation file so that call sites have an easier time inlining the functionality.

[steveire]

clang/lib/ASTMatchers/ASTMatchersInternal.cpp

195

If I inline it I get

error: invalid use of incomplete type ‘class clang::ASTContext’

I think there was a drive at some point to use ASTContext less in header files.

[aaron.ballman]

clang/lib/ASTMatchers/ASTMatchersInternal.cpp

195

Thanks for checking!

clang/include/clang/ASTMatchers/ASTMatchersInternal.h

bool matchesAncestorOf(const T &Node,
     return matchesAncestorOf(DynTypedNode::create(Node), getASTContext(),
                              Matcher, Builder, MatchMode);
   }
 
   virtual ASTContext &getASTContext() const = 0;
 
   virtual bool IsMatchingInTemplateInstantiationNotSpelledInSource() const = 0;
 
+  bool isTraversalAsIs() const;
+
 protected:
   virtual bool matchesChildOf(const DynTypedNode &Node, ASTContext &Ctx,
                               const DynTypedMatcher &Matcher,
                               BoundNodesTreeBuilder *Builder,
                               TraversalKind Traverse, BindKind Bind) = 0;
 
   virtual bool matchesDescendantOf(const DynTypedNode &Node, ASTContext &Ctx,
                                    const DynTypedMatcher &Matcher,

clang/lib/ASTMatchers/ASTMatchFinder.cpp

bool TraverseDecl(Decl *DeclNode) {
     ScopedIncrement ScopedDepth(&CurrentDepth);
     return (DeclNode == nullptr) || traverse(*DeclNode);
   }
 
   Stmt *getStmtToTraverse(Stmt *StmtNode) {
     Stmt *StmtToTraverse = StmtNode;
     if (auto *ExprNode = dyn_cast_or_null<Expr>(StmtNode)) {
       auto *LambdaNode = dyn_cast_or_null<LambdaExpr>(StmtNode);
-      if (LambdaNode &&
-          Finder->getASTContext().getParentMapContext().getTraversalKind() ==
-              TK_IgnoreUnlessSpelledInSource)
+      if (LambdaNode && !Finder->isTraversalAsIs())
         StmtToTraverse = LambdaNode;
       else
         StmtToTraverse =
             Finder->getASTContext().getParentMapContext().traverseIgnored(
                 ExprNode);
     }
     if (Traversal == TraversalKind::TK_IgnoreImplicitCastsAndParentheses) {
       if (Expr *ExprNode = dyn_cast_or_null<Expr>(StmtNode))
bool TraverseConstructorInitializer(CXXCtorInitializer *CtorInit) {
     ScopedIncrement ScopedDepth(&CurrentDepth);
     return traverse(*CtorInit);
   }
   bool TraverseTemplateArgumentLoc(TemplateArgumentLoc TAL) {
     ScopedIncrement ScopedDepth(&CurrentDepth);
     return traverse(TAL);
   }
   bool TraverseLambdaExpr(LambdaExpr *Node) {
-    if (Finder->getASTContext().getParentMapContext().getTraversalKind() !=
-        TK_IgnoreUnlessSpelledInSource)
+    if (!Finder->isTraversalAsIs())
       return VisitorBase::TraverseLambdaExpr(Node);
     if (!Node)
       return true;
     ScopedIncrement ScopedDepth(&CurrentDepth);
 
     for (unsigned I = 0, N = Node->capture_size(); I != N; ++I) {
       const auto *C = Node->capture_begin() + I;
       if (!C->isExplicit())

clang/lib/ASTMatchers/ASTMatchersInternal.cpp

private:
   clang::TraversalKind TK;
   IntrusiveRefCntPtr<DynMatcherInterface> InnerMatcher;
 };
 
 } // namespace
 
 static llvm::ManagedStatic<TrueMatcherImpl> TrueMatcherInstance;
 
+bool ASTMatchFinder::isTraversalAsIs() const {
+  return getASTContext().getParentMapContext().getTraversalKind() == TK_AsIs;
+}
+
 DynTypedMatcher
 DynTypedMatcher::constructVariadic(DynTypedMatcher::VariadicOperator Op,
                                    ASTNodeKind SupportedKind,
                                    std::vector<DynTypedMatcher> InnerMatchers) {
   assert(!InnerMatchers.empty() && "Array must not be empty.");
   assert(llvm::all_of(InnerMatchers,
                       [SupportedKind](const DynTypedMatcher &M) {
                         return M.canConvertTo(SupportedKind);

 }
 
 bool DynTypedMatcher::matches(const DynTypedNode &DynNode,
                               ASTMatchFinder *Finder,
                               BoundNodesTreeBuilder *Builder) const {
   TraversalKindScope RAII(Finder->getASTContext(),
                           Implementation->TraversalKind());
 
-  if (Finder->getASTContext().getParentMapContext().getTraversalKind() ==
-          TK_IgnoreUnlessSpelledInSource &&
+  if (!Finder->isTraversalAsIs() &&
       Finder->IsMatchingInTemplateInstantiationNotSpelledInSource())
     return false;
 
   auto N =
       Finder->getASTContext().getParentMapContext().traverseIgnored(DynNode);
 
   if (RestrictKind.isBaseOf(N.getNodeKind()) &&
       Implementation->dynMatches(N, 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 DynTypedNode &DynNode,
                                          ASTMatchFinder *Finder,
                                          BoundNodesTreeBuilder *Builder) const {
   TraversalKindScope raii(Finder->getASTContext(),
                           Implementation->TraversalKind());
 
-  if (Finder->getASTContext().getParentMapContext().getTraversalKind() ==
-          TK_IgnoreUnlessSpelledInSource &&
+  if (!Finder->isTraversalAsIs() &&
       Finder->IsMatchingInTemplateInstantiationNotSpelledInSource())
     return false;
 
   auto N =
       Finder->getASTContext().getParentMapContext().traverseIgnored(DynNode);
 
   assert(RestrictKind.isBaseOf(N.getNodeKind()));
   if (Implementation->dynMatches(N, Finder, Builder)) {