Extend ExprTraversal class with acending traversal

[steveire]

Summary

This allows ASTContext to store only one parent map, rather than storing
an entire parent map for each traversal mode used.

This is therefore a partial revert of commit 0a717d5b (Make it possible
control matcher traversal kind with ASTContext, 2019-12-06).

[steveire]

Format

[aaron.ballman]

Test cases?

clang/lib/AST/ASTContext.cpp

1066

Please spell the type out instead of using auto.

1070

const auto * (same below) because the type is spelled out in the initialization.

1083

const auto * so we don't have to infer the constness (same below with P).

clang/lib/AST/ExprTraversal.cpp

279

const auto * here and elsewhere

[rsmith]

We're working on moving the parent map out of ASTContext and into something specific to tooling; please don't add more dependencies onto it in the AST library.

clang/include/clang/AST/ASTContext.h

private:
 
   // FIXME: This currently contains the set of StoredDeclMaps used
   // by DeclContext objects.  This probably should not be in ASTContext,
   // but we include it here so that ASTContext can quickly deallocate them.
   llvm::PointerIntPair<StoredDeclsMap *, 1> LastSDM;
 
   std::vector<Decl *> TraversalScope;
   class ParentMap;
-  std::map<ast_type_traits::TraversalKind, std::unique_ptr<ParentMap>> Parents;
+  std::unique_ptr<ParentMap> Parents;
 
   std::unique_ptr<VTableContextBase> VTContext;
 
   void ReleaseDeclContextMaps();
 
 public:
   enum PragmaSectionFlag : unsigned {
     PSF_None = 0,

clang/include/clang/AST/ExprTraversal.h

struct ExprTraversal
   static Expr *DescendIgnoreParens(Expr *E);
   static Expr *DescendIgnoreParenImpCasts(Expr *E);
   static Expr *DescendIgnoreParenCasts(Expr *E);
   static Expr *DescendIgnoreConversionOperator(Expr *E);
   static Expr *DescendIgnoreParenLValueCasts(Expr *E);
   static Expr *DescendIgnoreParenBaseCasts(Expr *E);
   static Expr *DescendIgnoreParenNoopCasts(const ASTContext &Ctx, Expr *E);
   static Expr *DescendIgnoreUnlessSpelledInSource(Expr *E);
+
+  static bool AscendSkipUnlessSpelledInSource(const Expr *E, const Expr *Child);
 };
 
 }
 
 #endif

clang/lib/AST/ASTContext.cpp

 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclContextInternals.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclOpenMP.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/DeclarationName.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
+#include "clang/AST/ExprTraversal.h"
 #include "clang/AST/ExternalASTSource.h"
 #include "clang/AST/Mangle.h"
 #include "clang/AST/MangleNumberingContext.h"
 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/AST/RawCommentList.h"
 #include "clang/AST/RecordLayout.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/AST/Stmt.h"
for (const auto &Entry : OtherParents) {
       if (Entry.second.is<ast_type_traits::DynTypedNode *>()) {
         delete Entry.second.get<ast_type_traits::DynTypedNode *>();
       } else if (Entry.second.is<ParentVector *>()) {
         delete Entry.second.get<ParentVector *>();
       }
     }
   }
 
-  DynTypedNodeList getParents(const ast_type_traits::DynTypedNode &Node) {
-    if (Node.getNodeKind().hasPointerIdentity())
-      return getDynNodeFromMap(Node.getMemoizationData(), PointerParents);
+  DynTypedNodeList getParents(ast_type_traits::TraversalKind TK, const ast_type_traits::DynTypedNode &Node) {
+    if (Node.getNodeKind().hasPointerIdentity()) {
+      auto ParentList = getDynNodeFromMap(Node.getMemoizationData(), PointerParents);
+      if (ParentList.size() == 1 && TK == ast_type_traits::TK_IgnoreUnlessSpelledInSource) {
+        const Expr* E = ParentList[0].get<Expr>();
+        const Expr* Child = Node.get<Expr>();
+        if (E && Child)
+          return AscendIgnoreUnlessSpelledInSource(E, Child);
+      }
+      return ParentList;
+    }
     return getDynNodeFromMap(Node, OtherParents);
   }
+
+  ast_type_traits::DynTypedNode AscendIgnoreUnlessSpelledInSource(const Expr* E, const Expr* Child)
+  {
+    while (ExprTraversal::AscendSkipUnlessSpelledInSource(E, Child)) {
+      auto It = PointerParents.find(E);
+      if (It == PointerParents.end())
+        break;
+      auto *S = It->second.dyn_cast<const Stmt *>();
+      if (!S)
+        return getSingleDynTypedNodeFromParentMap(It->second);
+      auto *P = dyn_cast<Expr>(S);
+      if (!P)
+        return ast_type_traits::DynTypedNode::create(*S);
+      Child = E;
+      E = P;
+    }
+    return ast_type_traits::DynTypedNode::create(*E);
+  }
 };
 
 void ASTContext::setTraversalScope(const std::vector<Decl *> &TopLevelDecls) {
   TraversalScope = TopLevelDecls;
-  Parents.clear();
+  Parents.reset();
 }
 
 void ASTContext::AddDeallocation(void (*Callback)(void *), void *Data) const {
   Deallocations.push_back({Callback, Data});
 }
 
 void
 ASTContext::setExternalSource(IntrusiveRefCntPtr<ExternalASTSource> Source) {

 /// Note that the relationship described here is purely in terms of AST
 /// traversal - there are other relationships (for example declaration context)
 /// in the AST that are better modeled by special matchers.
 ///
 /// FIXME: Currently only builds up the map using \c Stmt and \c Decl nodes.
 class ASTContext::ParentMap::ASTVisitor
     : public RecursiveASTVisitor<ASTVisitor> {
 public:
-  ASTVisitor(ParentMap &Map, ASTContext &Context)
-      : Map(Map), Context(Context) {}
+  ASTVisitor(ParentMap &Map)
+      : Map(Map) {}
 
 private:
   friend class RecursiveASTVisitor<ASTVisitor>;
 
   using VisitorBase = RecursiveASTVisitor<ASTVisitor>;
 
   bool shouldVisitTemplateInstantiations() const { return true; }
 
private:
 
   bool TraverseDecl(Decl *DeclNode) {
     return TraverseNode(
         DeclNode, DeclNode, [&] { return VisitorBase::TraverseDecl(DeclNode); },
         &Map.PointerParents);
   }
 
   bool TraverseStmt(Stmt *StmtNode) {
-    Stmt *FilteredNode = StmtNode;
-    if (auto *ExprNode = dyn_cast_or_null<Expr>(FilteredNode))
-      FilteredNode = Context.traverseIgnored(ExprNode);
-    return TraverseNode(FilteredNode, FilteredNode,
-                        [&] { return VisitorBase::TraverseStmt(FilteredNode); },
+    return TraverseNode(StmtNode, StmtNode,
+                        [&] { return VisitorBase::TraverseStmt(StmtNode); },
                         &Map.PointerParents);
   }
 
   bool TraverseTypeLoc(TypeLoc TypeLocNode) {
     return TraverseNode(
         TypeLocNode, ast_type_traits::DynTypedNode::create(TypeLocNode),
         [&] { return VisitorBase::TraverseTypeLoc(TypeLocNode); },
         &Map.OtherParents);
   }
 
   bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNSLocNode) {
     return TraverseNode(
         NNSLocNode, ast_type_traits::DynTypedNode::create(NNSLocNode),
         [&] { return VisitorBase::TraverseNestedNameSpecifierLoc(NNSLocNode); },
         &Map.OtherParents);
   }
 
   ParentMap &Map;
-  ASTContext &Context;
   llvm::SmallVector<ast_type_traits::DynTypedNode, 16> ParentStack;
 };
 
 ASTContext::ParentMap::ParentMap(ASTContext &Ctx) {
-  ASTVisitor(*this, Ctx).TraverseAST(Ctx);
+  ASTVisitor(*this).TraverseAST(Ctx);
 }
 
 ASTContext::DynTypedNodeList
 ASTContext::getParents(const ast_type_traits::DynTypedNode &Node) {
-  std::unique_ptr<ParentMap> &P = Parents[Traversal];
-  if (!P)
+  if (!Parents)
     // We build the parent map for the traversal scope (usually whole TU), as
     // hasAncestor can escape any subtree.
-    P = std::make_unique<ParentMap>(*this);
-  return P->getParents(Node);
+    Parents = std::make_unique<ParentMap>(*this);
+  return Parents->getParents(getTraversalKind(), Node);
 }
 
 bool
 ASTContext::ObjCMethodsAreEqual(const ObjCMethodDecl *MethodDecl,
                                 const ObjCMethodDecl *MethodImpl) {
   // No point trying to match an unavailable/deprecated mothod.
   if (MethodDecl->hasAttr<UnavailableAttr>()
       || MethodDecl->hasAttr<DeprecatedAttr>())

clang/lib/AST/ExprTraversal.cpp

if (auto *C = dyn_cast<CXXMemberCallExpr>(E)) {
       Expr *ExprNode = C->getImplicitObjectArgument()->IgnoreParenImpCasts();
       if (ExprNode->getSourceRange() == SR)
         E = ExprNode;
     }
   }
 
   return E;
 }
+
+bool ExprTraversal::AscendSkipUnlessSpelledInSource(const Expr *E, const Expr* Child) {
+  if (isa<ImplicitCastExpr>(E))
+    return true;
+
+  if (isa<FullExpr>(E))
+    return true;
+
+  if (isa<MaterializeTemporaryExpr>(E))
+    return true;
+
+  if (isa<CXXBindTemporaryExpr>(E))
+    return true;
+
+  if (isa<ParenExpr>(E))
+    return true;
+
+  if (isa<ExprWithCleanups>(E))
+    return true;
+
+  auto SR = Child->getSourceRange();
+
+  if (auto *C = dyn_cast<CXXConstructExpr>(E)) {
+    if (C->getSourceRange() == SR || !isa<CXXTemporaryObjectExpr>(C))
+      return true;
+  }
+
+  if (auto *C = dyn_cast<CXXMemberCallExpr>(E)) {
+    if (C->getSourceRange() == SR)
+      return true;
+  }
+
+  if (auto *C = dyn_cast<MemberExpr>(E)) {
+    if (C->getSourceRange() == SR)
+      return true;
+  }
+  return false;
+}