[[Clang CallGraph]] CallGraph should still record calls to decls.

[erichkeane]

Summary

Discovered by a downstream user, we found that the CallGraph ignores
callees unless they are defined. This seems foolish, and prevents
combining the report with other reports to create unified reports.
Additionally, declarations contain information that is likely useful to
consumers of the CallGraph.

This patch implements this by splitting the includeInGraph function into
two versions, the current one plus one that is for callees only. The
only difference currently is that includeInGraph checks for a body, then
calls includeCalleeInGraph.

[lebedev.ri]

clang/test/Analysis/debug-CallGraph.cpp

84–100

Can you precommit these?

[erichkeane]

clang/test/Analysis/debug-CallGraph.cpp

84–100

Done here: https://github.com/llvm/llvm-project/commit/a983562b23458777a7226ec6cfe41cbeb9d291de

I'll rebase this on top of it asap.

[erichkeane]

Precommited the test.

[lebedev.ri]

LGTM unless @NoQ has concerns.

[lebedev.ri]

Whoops, i did not see cfe-commits again got sidestepped.

clang/include/clang/Analysis/CallGraph.h

public:
   /// Recursively walks the declaration to find all the dependent Decls as well.
   void addToCallGraph(Decl *D) {
     TraverseDecl(D);
   }
 
   /// Determine if a declaration should be included in the graph.
   static bool includeInGraph(const Decl *D);
 
+  /// Determine if a declaration should be included in the graph for the 
+  /// purposes of being a callee. This is similar to includeInGraph except
+  /// it permits declarations, not just definitions.
+  static bool includeCalleeInGraph(const Decl *D);
+
   /// Lookup the node for the given declaration.
   CallGraphNode *getNode(const Decl *) const;
 
   /// Lookup the node for the given declaration. If none found, insert
   /// one into the graph.
   CallGraphNode *getOrInsertNode(Decl *);
 
   using iterator = FunctionMapTy::iterator;

clang/lib/Analysis/CallGraph.cpp

if (BlockExpr *Block = dyn_cast<BlockExpr>(CEE)) {
       NumBlockCallEdges++;
       return Block->getBlockDecl();
     }
 
     return nullptr;
   }
 
   void addCalledDecl(Decl *D, Expr *CallExpr) {
-    if (G->includeInGraph(D)) {
+    if (G->includeCalleeInGraph(D)) {
       CallGraphNode *CalleeNode = G->getOrInsertNode(D);
       CallerNode->addCallee({CalleeNode, CallExpr});
     }
   }
 
   void VisitCallExpr(CallExpr *CE) {
     if (Decl *D = getDeclFromCall(CE))
       addCalledDecl(D, CE);

 
 CallGraph::~CallGraph() = default;
 
 bool CallGraph::includeInGraph(const Decl *D) {
   assert(D);
   if (!D->hasBody())
     return false;
 
+  return includeCalleeInGraph(D);
+}
+
+bool CallGraph::includeCalleeInGraph(const Decl *D) {
   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
     // We skip function template definitions, as their semantics is
     // only determined when they are instantiated.
     if (FD->isDependentContext())
       return false;
 
     IdentifierInfo *II = FD->getIdentifier();
     if (II && II->getName().startswith("__inline"))

clang/test/Analysis/debug-CallGraph.cpp

[](int i) {
       Callee();
     }(1);
     [](auto i) {
       Callee();
     }(1);
   }
 }
 
 namespace CallDecl {
   void SomeDecl();
   void SomeOtherDecl();
   void SomeDef() {}
 
   void Caller() {
     SomeDecl();
     SomeOtherDecl();
   }
 
   void SomeOtherDecl() {
     SomeDef();
   }
 }
 
 // CHECK:--- Call graph Dump ---
-// CHECK-NEXT: {{Function: < root > calls: get5 add test_add mmm foo aaa < > bbb ddd ccc eee fff do_nothing test_single_call SomeNS::templ SomeNS::templ SomeNS::templUser Lambdas::Callee Lambdas::f1 Lambdas::f1\(\)::\(anonymous class\)::operator\(\) Lambdas::f1\(\)::\(anonymous class\)::operator\(\) CallDecl::SomeDef CallDecl::Caller CallDecl::SomeOtherDecl $}}
-// CHECK-NEXT: {{Function: CallDecl::Caller calls: CallDecl::SomeOtherDecl $}}
+// CHECK-NEXT: {{Function: < root > calls: get5 add test_add mmm foo aaa < > bbb ddd ccc eee fff do_nothing test_single_call SomeNS::templ SomeNS::templ SomeNS::templUser Lambdas::Callee Lambdas::f1 Lambdas::f1\(\)::\(anonymous class\)::operator\(\) Lambdas::f1\(\)::\(anonymous class\)::operator\(\) CallDecl::SomeDef CallDecl::Caller CallDecl::SomeDecl CallDecl::SomeOtherDecl $}}
+// CHECK-NEXT: {{Function: CallDecl::Caller calls: CallDecl::SomeDecl CallDecl::SomeOtherDecl $}}
 // CHECK-NEXT: {{Function: CallDecl::SomeOtherDecl calls: CallDecl::SomeDef $}}
+// CHECK-NEXT: {{Function: CallDecl::SomeDecl calls: $}}
 // CHECK-NEXT: {{Function: CallDecl::SomeDef calls: $}}
 // CHECK-NEXT: {{Function: Lambdas::f1 calls: Lambdas::f1\(\)::\(anonymous class\)::operator\(\) Lambdas::f1\(\)::\(anonymous class\)::operator\(\) $}}
 // CHECK-NEXT: {{Function: Lambdas::f1\(\)::\(anonymous class\)::operator\(\) calls: Lambdas::Callee $}}
 // CHECK-NEXT: {{Function: Lambdas::f1\(\)::\(anonymous class\)::operator\(\) calls: Lambdas::Callee $}}
 // CHECK-NEXT: {{Function: Lambdas::Callee calls: $}}
 // CHECK-NEXT: {{Function: SomeNS::templUser calls: SomeNS::templ SomeNS::templ $}}
 // CHECK-NEXT: {{Function: SomeNS::templ calls: eee $}}
 // CHECK-NEXT: {{Function: SomeNS::templ calls: ccc $}}