[Analysis] Use unique_ptr for CallGraph::FunctionMap.

[jlebar]

Summary

The decltype(declval) dance in the iterator traits is necessary because
DenseMap iterators aren't over std::pairs, but rather are over a
pair-like type defined in DenseMap. It used to work because we were
making a copy of the pair, but now that we're binding a reference to the
pair, we need to get the type exactly right.

[timshen]

clang/include/clang/Analysis/CallGraph.h

204

Does clang::CallGraph::const_iterator::value_type work?

[jlebar]

clang/include/clang/Analysis/CallGraph.h

204

Much better, thanks.

[jlebar]

https://github.com/llvm-mirror/clang/commit/b28828e8b38c7e208386f783e6502305c42cb479

clang/include/clang/Analysis/CallGraph.h

 /// \brief The AST-based call graph.
 ///
 /// The call graph extends itself with the given declarations by implementing
 /// the recursive AST visitor, which constructs the graph by visiting the given
 /// declarations.
 class CallGraph : public RecursiveASTVisitor<CallGraph> {
   friend class CallGraphNode;
 
-  typedef llvm::DenseMap<const Decl *, CallGraphNode *> FunctionMapTy;
+  typedef llvm::DenseMap<const Decl *, std::unique_ptr<CallGraphNode>>
+      FunctionMapTy;
 
   /// FunctionMap owns all CallGraphNodes.
   FunctionMapTy FunctionMap;
 
   /// This is a virtual root node that has edges to all the functions.
   CallGraphNode *Root;
 
 public:

 };
 
 template <> struct GraphTraits<clang::CallGraph*>
   : public GraphTraits<clang::CallGraphNode*> {
 
   static NodeType *getEntryNode(clang::CallGraph *CGN) {
     return CGN->getRoot();  // Start at the external node!
   }
-  typedef std::pair<const clang::Decl*, clang::CallGraphNode*> PairTy;
 
-  static clang::CallGraphNode *CGGetValue(PairTy P) { return P.second; }
+  static clang::CallGraphNode *
+  CGGetValue(decltype(*std::declval<clang::CallGraph::const_iterator>()) &P) {
+    return P.second.get();
+  }
 
   // nodes_iterator/begin/end - Allow iteration over all nodes in the graph
   typedef mapped_iterator<clang::CallGraph::iterator, decltype(&CGGetValue)>
       nodes_iterator;
 
   static nodes_iterator nodes_begin(clang::CallGraph *CG) {
     return nodes_iterator(CG->begin(), &CGGetValue);
   }
   static nodes_iterator nodes_end  (clang::CallGraph *CG) {
     return nodes_iterator(CG->end(), &CGGetValue);
   }
 
   static unsigned size(clang::CallGraph *CG) {
     return CG->size();
   }
 };
 
 template <> struct GraphTraits<const clang::CallGraph*> :
   public GraphTraits<const clang::CallGraphNode*> {
   static NodeType *getEntryNode(const clang::CallGraph *CGN) {
     return CGN->getRoot();
   }
-  typedef std::pair<const clang::Decl*, clang::CallGraphNode*> PairTy;
 
-  static clang::CallGraphNode *CGGetValue(PairTy P) { return P.second; }
+  static clang::CallGraphNode *
+  CGGetValue(decltype(*std::declval<clang::CallGraph::const_iterator>()) &P) {
+    return P.second.get();
+  }
 
   // nodes_iterator/begin/end - Allow iteration over all nodes in the graph
   typedef mapped_iterator<clang::CallGraph::const_iterator,
                           decltype(&CGGetValue)>
       nodes_iterator;
 
   static nodes_iterator nodes_begin(const clang::CallGraph *CG) {
     return nodes_iterator(CG->begin(), &CGGetValue);

clang/lib/Analysis/CallGraph.cpp

for (auto *I : D->decls())
     if (auto *DC = dyn_cast<DeclContext>(I))
       addNodesForBlocks(DC);
 }
 
 CallGraph::CallGraph() {
   Root = getOrInsertNode(nullptr);
 }
 
-CallGraph::~CallGraph() {
-  llvm::DeleteContainerSeconds(FunctionMap);
-}
+CallGraph::~CallGraph() {}
 
 bool CallGraph::includeInGraph(const Decl *D) {
   assert(D);
   if (!D->hasBody())
     return false;
 
   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
     // We skip function template definitions, as their semantics is
void CallGraph::addNodeForDecl(Decl* D, bool IsGlobal) {
   CGBuilder builder(this, Node);
   if (Stmt *Body = D->getBody())
     builder.Visit(Body);
 }
 
 CallGraphNode *CallGraph::getNode(const Decl *F) const {
   FunctionMapTy::const_iterator I = FunctionMap.find(F);
   if (I == FunctionMap.end()) return nullptr;
-  return I->second;
+  return I->second.get();
 }
 
 CallGraphNode *CallGraph::getOrInsertNode(Decl *F) {
   if (F && !isa<ObjCMethodDecl>(F))
     F = F->getCanonicalDecl();
 
-  CallGraphNode *&Node = FunctionMap[F];
+  std::unique_ptr<CallGraphNode> &Node = FunctionMap[F];
   if (Node)
-    return Node;
+    return Node.get();
 
-  Node = new CallGraphNode(F);
+  Node = llvm::make_unique<CallGraphNode>(F);
   // Make Root node a parent of all functions to make sure all are reachable.
   if (F)
-    Root->addCallee(Node, this);
-  return Node;
+    Root->addCallee(Node.get(), this);
+  return Node.get();
 }
 
 void CallGraph::print(raw_ostream &OS) const {
   OS << " --- Call graph Dump --- \n";
 
   // We are going to print the graph in reverse post order, partially, to make
   // sure the output is deterministic.
   llvm::ReversePostOrderTraversal<const clang::CallGraph*> RPOT(this);