Implement the RefKind::Call optimization

Author: HighCommander4

clang-tools-extra/clangd/XRefs.cpp

@@ -2319,10 +2319,10 @@ outgoingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index) {
   // In this function, we find outgoing calls based on the index only.
   RefsRequest Request;
   Request.IDs.insert(*ID);
-  // We could restrict more specifically to calls by introducing a new RefKind,
-  // but non-call references (such as address-of-function) can still be
-  // interesting as they can indicate indirect calls.
-  Request.Filter = RefKind::Reference;
+  // Note that RefKind::Call just restricts the matched SymbolKind to
+  // functions, not the form of the reference (e.g. address-of-function,
+  // which can indicate an indirect call, should still be caught).
+  Request.Filter = RefKind::Call;
   // Initially store the ranges in a map keyed by SymbolID of the callee.
   // This allows us to group different calls to the same function
   // into the same CallHierarchyOutgoingCall.
@@ -2347,11 +2347,11 @@ outgoingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index) {
     // Filter references to only keep function calls
     using SK = index::SymbolKind;
     auto Kind = Callee.SymInfo.Kind;
-    if (Kind != SK::Function && Kind != SK::InstanceMethod &&
-        Kind != SK::ClassMethod && Kind != SK::StaticMethod &&
-        Kind != SK::Constructor && Kind != SK::Destructor &&
-        Kind != SK::ConversionFunction)
-      return;
+    bool NotCall = (Kind != SK::Function && Kind != SK::InstanceMethod &&
+                    Kind != SK::ClassMethod && Kind != SK::StaticMethod &&
+                    Kind != SK::Constructor && Kind != SK::Destructor &&
+                    Kind != SK::ConversionFunction);
+    assert(!NotCall);
 
     auto It = CallsOut.find(Callee.ID);
     assert(It != CallsOut.end());

clang-tools-extra/clangd/index/Ref.h

@@ -63,6 +63,9 @@ enum class RefKind : uint8_t {
   //   ^ this references Foo, but does not explicitly spell out its name
   // };
   Spelled = 1 << 3,
+  // A reference which is a call. Used as a filter for which references
+  // to store in data structures used for computing outgoing calls.
+  Call = 1 << 4,
   All = Declaration | Definition | Reference | Spelled,
 };
 

clang-tools-extra/clangd/index/SymbolCollector.cpp

@@ -18,6 +18,7 @@
 #include "clang-include-cleaner/Record.h"
 #include "clang-include-cleaner/Types.h"
 #include "index/CanonicalIncludes.h"
+#include "index/Ref.h"
 #include "index/Relation.h"
 #include "index/Symbol.h"
 #include "index/SymbolID.h"
@@ -617,7 +618,7 @@ bool SymbolCollector::handleDeclOccurrence(
     auto FileLoc = SM.getFileLoc(Loc);
     auto FID = SM.getFileID(FileLoc);
     if (Opts.RefsInHeaders || FID == SM.getMainFileID()) {
-      addRef(ID, SymbolRef{FileLoc, FID, Roles,
+      addRef(ID, SymbolRef{FileLoc, FID, Roles, index::getSymbolInfo(ND).Kind,
                            getRefContainer(ASTNode.Parent, Opts),
                            isSpelled(FileLoc, *ND)});
     }
@@ -731,8 +732,10 @@ bool SymbolCollector::handleMacroOccurrence(const IdentifierInfo *Name,
     // FIXME: Populate container information for macro references.
     // FIXME: All MacroRefs are marked as Spelled now, but this should be
     // checked.
-    addRef(ID, SymbolRef{Loc, SM.getFileID(Loc), Roles, /*Container=*/nullptr,
-                         /*Spelled=*/true});
+    addRef(ID,
+           SymbolRef{Loc, SM.getFileID(Loc), Roles, index::SymbolKind::Macro,
+                     /*Container=*/nullptr,
+                     /*Spelled=*/true});
   }
 
   // Collect symbols.
@@ -1123,6 +1126,14 @@ bool SymbolCollector::shouldIndexFile(FileID FID) {
   return I.first->second;
 }
 
+static bool refIsCall(index::SymbolKind Kind) {
+  using SK = index::SymbolKind;
+  return Kind == SK::Function || Kind == SK::InstanceMethod ||
+         Kind == SK::ClassMethod || Kind == SK::StaticMethod ||
+         Kind == SK::Constructor || Kind == SK::Destructor ||
+         Kind == SK::ConversionFunction;
+}
+
 void SymbolCollector::addRef(SymbolID ID, const SymbolRef &SR) {
   const auto &SM = ASTCtx->getSourceManager();
   // FIXME: use the result to filter out references.
@@ -1134,6 +1145,9 @@ void SymbolCollector::addRef(SymbolID ID, const SymbolRef &SR) {
     R.Location.End = Range.second;
     R.Location.FileURI = HeaderFileURIs->toURI(*FE).c_str();
     R.Kind = toRefKind(SR.Roles, SR.Spelled);
+    if (refIsCall(SR.Kind)) {
+      R.Kind |= RefKind::Call;
+    }
     R.Container = getSymbolIDCached(SR.Container);
     Refs.insert(ID, R);
   }

clang-tools-extra/clangd/index/SymbolCollector.h

@@ -209,6 +209,7 @@ class SymbolCollector : public index::IndexDataConsumer {
     SourceLocation Loc;
     FileID FID;
     index::SymbolRoleSet Roles;
+    index::SymbolKind Kind;
     const Decl *Container;
     bool Spelled;
   };

clang-tools-extra/clangd/index/dex/Dex.cpp

@@ -151,7 +151,8 @@ void Dex::buildIndex() {
   // Build RevRefs
   for (const auto &Pair : Refs)
     for (const auto &R : Pair.second)
-      RevRefs[R.Container].emplace_back(R, Pair.first);
+      if ((R.Kind & RefKind::Call) != RefKind::Unknown)
+        RevRefs[R.Container].emplace_back(R, Pair.first);
 }
 
 std::unique_ptr<Iterator> Dex::iterator(const Token &Tok) const {