[clang-tools-extra] Determine the access method to a referenced symbol. (PR #172462)
Dimitri Ratz via cfe-commits
cfe-commits at lists.llvm.org
Sat May 23 15:23:16 PDT 2026
https://github.com/ratzdi updated https://github.com/llvm/llvm-project/pull/172462
>From f4f37212f33182f0f65a0f9ae0f4db58f94dedf4 Mon Sep 17 00:00:00 2001
From: Dimitri Ratz <dimitri.ratz at thinkdigital.cc>
Date: Wed, 10 Dec 2025 16:20:56 +0100
Subject: [PATCH 01/11] Determine the access method to a referenced symbol.
The access method helps to know in a quick way, what is happening with the referenced symbol somewhere in the code, i.e.
is the referenced symbol used as a rvalue object to read a value from or as lvalue object to write some value into.
The basic access methods to a referenced symbol can be write and/or read.
---
clang-tools-extra/clangd/Protocol.cpp | 9 +-
clang-tools-extra/clangd/Protocol.h | 13 +++
clang-tools-extra/clangd/XRefs.cpp | 147 ++++++++++++++++++++++++--
3 files changed, 158 insertions(+), 11 deletions(-)
diff --git a/clang-tools-extra/clangd/Protocol.cpp b/clang-tools-extra/clangd/Protocol.cpp
index 560b8e00ed377..6027e60609fe2 100644
--- a/clang-tools-extra/clangd/Protocol.cpp
+++ b/clang-tools-extra/clangd/Protocol.cpp
@@ -209,7 +209,7 @@ bool fromJSON(const llvm::json::Value &Params, ChangeAnnotation &R,
O.map("needsConfirmation", R.needsConfirmation) &&
O.mapOptional("description", R.description);
}
-llvm::json::Value toJSON(const ChangeAnnotation & CA) {
+llvm::json::Value toJSON(const ChangeAnnotation &CA) {
llvm::json::Object Result{{"label", CA.label}};
if (CA.needsConfirmation)
Result["needsConfirmation"] = *CA.needsConfirmation;
@@ -1478,6 +1478,10 @@ llvm::json::Value toJSON(SymbolTag Tag) {
return llvm::json::Value(static_cast<int>(Tag));
}
+llvm::json::Value toJSON(ReferenceTag Tag) {
+ return llvm::json::Value(static_cast<int>(Tag));
+}
+
llvm::json::Value toJSON(const CallHierarchyItem &I) {
llvm::json::Object Result{{"name", I.name},
{"kind", static_cast<int>(I.kind)},
@@ -1490,6 +1494,9 @@ llvm::json::Value toJSON(const CallHierarchyItem &I) {
Result["detail"] = I.detail;
if (!I.data.empty())
Result["data"] = I.data;
+ if (!I.referenceTags.empty())
+ Result["referenceTags"] = I.referenceTags;
+
return std::move(Result);
}
diff --git a/clang-tools-extra/clangd/Protocol.h b/clang-tools-extra/clangd/Protocol.h
index 2248572060431..edb28ef33d6a2 100644
--- a/clang-tools-extra/clangd/Protocol.h
+++ b/clang-tools-extra/clangd/Protocol.h
@@ -405,6 +405,13 @@ enum class SymbolKind {
Operator = 25,
TypeParameter = 26
};
+
+/// Tags describing the reference kind.
+enum class ReferenceTag {
+ Read = 1,
+ Write = 2,
+};
+
bool fromJSON(const llvm::json::Value &, SymbolKind &, llvm::json::Path);
constexpr auto SymbolKindMin = static_cast<size_t>(SymbolKind::File);
constexpr auto SymbolKindMax = static_cast<size_t>(SymbolKind::TypeParameter);
@@ -1513,6 +1520,9 @@ struct TypeHierarchyItem {
/// The kind of this item.
SymbolKind kind;
+ /// The symbol tags for this item.
+ std::vector<ReferenceTag> referenceTags;
+
/// More detail for this item, e.g. the signature of a function.
std::optional<std::string> detail;
@@ -1590,6 +1600,9 @@ struct CallHierarchyItem {
/// Tags for this item.
std::vector<SymbolTag> tags;
+ /// The tags describing reference kinds of this item.
+ std::vector<ReferenceTag> referenceTags;
+
/// More detaill for this item, e.g. the signature of a function.
std::string detail;
diff --git a/clang-tools-extra/clangd/XRefs.cpp b/clang-tools-extra/clangd/XRefs.cpp
index ef45acf501612..fd4dfe95213a5 100644
--- a/clang-tools-extra/clangd/XRefs.cpp
+++ b/clang-tools-extra/clangd/XRefs.cpp
@@ -68,6 +68,7 @@
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/raw_ostream.h"
+#include "support/Logger.h"
#include <algorithm>
#include <optional>
#include <string>
@@ -1749,6 +1750,130 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
return OS;
}
+// This would require a visitor pattern:
+class ParamUsageVisitor : public RecursiveASTVisitor<ParamUsageVisitor> {
+public:
+ bool HasWrite = false;
+ bool HasRead = false;
+ const ParmVarDecl *TargetParam;
+
+ ParamUsageVisitor(const ParmVarDecl *P) : TargetParam(P) {}
+
+ bool VisitUnaryOperator(UnaryOperator *UO) {
+ // Check for increment/decrement on parameter
+ if (UO->isIncrementDecrementOp()) {
+ if (auto *DRE = dyn_cast<DeclRefExpr>(UO->getSubExpr())) {
+ if (DRE->getDecl() == TargetParam) {
+ HasWrite = true;
+ }
+ }
+ }
+ return true;
+ }
+
+ bool VisitBinaryOperator(BinaryOperator *BO) {
+ // Check for assignment to parameter
+ if (BO->isAssignmentOp()) {
+ if (auto *DRE = dyn_cast<DeclRefExpr>(BO->getLHS())) {
+ if (DRE->getDecl() == TargetParam) {
+ HasWrite = true;
+ }
+ }
+ }
+ // Any other use is at least a read
+ if (auto *DRE = dyn_cast<DeclRefExpr>(BO->getRHS())) {
+ if (DRE->getDecl() == TargetParam) {
+ HasRead = true;
+ }
+ }
+ return true;
+ }
+};
+
+static std::vector<ReferenceTag> analyseParameterUsage(const FunctionDecl *FD) {
+ std::vector<ReferenceTag> Result;
+ // This requires more sophisticated analysis - checking if param is modified
+ const Stmt *Body = FD->getBody();
+ if (!Body)
+ return Result; // No definition available
+
+ for (unsigned I = 0; I < FD->getNumParams(); ++I) {
+ const ParmVarDecl *Param = FD->getParamDecl(I);
+
+ // Check const qualifier
+ // QualType ParamType = Param->getType();
+ // bool IsReadOnly = ParamType.isConstQualified();
+
+ // For deeper analysis, you'd need to:
+ // 1. Walk the AST of the function body
+ // 2. Find all references to the parameter
+ // 3. Check if they appear on the left side of assignments (write)
+ // or only on the right side (read)
+
+ ParamUsageVisitor Visitor(Param);
+ Visitor.TraverseStmt(const_cast<Stmt *>(Body));
+ if (Visitor.HasWrite)
+ Result.push_back(ReferenceTag::Write);
+ if (Visitor.HasRead)
+ Result.push_back(ReferenceTag::Read);
+ }
+ return Result;
+}
+
+template <typename HierarchyItem>
+static void determineParameterUsage(const NamedDecl &ND, HierarchyItem &HI) {
+ // Get parent context and check if it's a function parameter
+ const DeclContext *DC = ND.getDeclContext();
+ elog("determineParameterUsage: called for ND={0}", ND.getNameAsString());
+ if (const auto *TD = llvm::dyn_cast<TagDecl>(DC)) {
+ elog("determineParameterUsage: ND is inside a TagDecl: {0}", TD->getNameAsString());
+ // No parameter analysis for TagDecl parent contexts.
+ } else if (const auto *FD = llvm::dyn_cast<FunctionDecl>(DC)) {
+ elog("determineParameterUsage: ND is inside a FunctionDecl");
+ for (unsigned I = 0; I < FD->getNumParams(); ++I) {
+ if (FD->getParamDecl(I) == &ND) {
+ elog("determineParameterUsage: ND is the {0}-th parameter of function {1}", I, FD->getNameAsString());
+
+ const ParmVarDecl *Param = FD->getParamDecl(I);
+ QualType ParamType = Param->getType();
+
+ bool IsConst = false;
+ bool IsConstRef = false;
+ bool IsConstPtr = false;
+
+ // Check if const (read-only)
+ IsConst = ParamType.isConstQualified();
+ elog("determineParameterUsage: ParamType.isConstQualified() = {0}", IsConst);
+
+ // Check if it's a const reference
+ if (const auto *RT = ParamType->getAs<ReferenceType>()) {
+ IsConstRef = RT->getPointeeType().isConstQualified();
+ elog("determineParameterUsage: ParamType is ReferenceType, isConstQualified = {0}", IsConstRef);
+ }
+
+ // Check if it's a const pointer
+ if (const auto *PT = ParamType->getAs<PointerType>()) {
+ IsConstPtr = PT->getPointeeType().isConstQualified();
+ elog("determineParameterUsage: ParamType is PointerType, isConstQualified = {0}", IsConstPtr);
+ }
+
+ if (IsConst && IsConstRef && IsConstPtr) {
+ elog("determineParameterUsage: All const checks passed, marking as Read");
+ HI.referenceTags.push_back(ReferenceTag::Read);
+ } else {
+ elog("determineParameterUsage: Performing analyseParameterUsage");
+ HI.referenceTags = analyseParameterUsage(FD);
+ }
+
+ break;
+ }
+ elog("determineParameterUsage: ND is not parameter {0} of function {1}", I, FD->getNameAsString());
+ }
+ } else {
+ elog("determineParameterUsage: ND is not inside a FunctionDecl or TagDecl");
+ }
+}
+
template <typename HierarchyItem>
static std::optional<HierarchyItem>
declToHierarchyItem(const NamedDecl &ND, llvm::StringRef TUPath) {
@@ -1790,6 +1915,8 @@ declToHierarchyItem(const NamedDecl &ND, llvm::StringRef TUPath) {
HI.range = HI.selectionRange;
}
+ determineParameterUsage(ND, HI);
+
HI.uri = URIForFile::canonicalize(*FilePath, TUPath);
return HI;
@@ -2097,15 +2224,15 @@ static QualType typeForNode(const ASTContext &Ctx, const HeuristicResolver *H,
return QualType();
}
-// Given a type targeted by the cursor, return one or more types that are more interesting
-// to target.
-static void unwrapFindType(
- QualType T, const HeuristicResolver* H, llvm::SmallVector<QualType>& Out) {
+// Given a type targeted by the cursor, return one or more types that are more
+// interesting to target.
+static void unwrapFindType(QualType T, const HeuristicResolver *H,
+ llvm::SmallVector<QualType> &Out) {
if (T.isNull())
return;
// If there's a specific type alias, point at that rather than unwrapping.
- if (const auto* TDT = T->getAs<TypedefType>())
+ if (const auto *TDT = T->getAs<TypedefType>())
return Out.push_back(QualType(TDT, 0));
// Pointers etc => pointee type.
@@ -2139,8 +2266,8 @@ static void unwrapFindType(
}
// Convenience overload, to allow calling this without the out-parameter
-static llvm::SmallVector<QualType> unwrapFindType(
- QualType T, const HeuristicResolver* H) {
+static llvm::SmallVector<QualType> unwrapFindType(QualType T,
+ const HeuristicResolver *H) {
llvm::SmallVector<QualType> Result;
unwrapFindType(T, H, Result);
return Result;
@@ -2162,9 +2289,9 @@ std::vector<LocatedSymbol> findType(ParsedAST &AST, Position Pos,
std::vector<LocatedSymbol> LocatedSymbols;
// NOTE: unwrapFindType might return duplicates for something like
- // unique_ptr<unique_ptr<T>>. Let's *not* remove them, because it gives you some
- // information about the type you may have not known before
- // (since unique_ptr<unique_ptr<T>> != unique_ptr<T>).
+ // unique_ptr<unique_ptr<T>>. Let's *not* remove them, because it gives you
+ // some information about the type you may have not known before (since
+ // unique_ptr<unique_ptr<T>> != unique_ptr<T>).
for (const QualType &Type : unwrapFindType(
typeForNode(AST.getASTContext(), AST.getHeuristicResolver(), N),
AST.getHeuristicResolver()))
>From 2c2a42c3c95cedcde8bd06ff23c68efc753ea5ab Mon Sep 17 00:00:00 2001
From: Dimitri Ratz <dimitri.ratz at thinkdigital.cc>
Date: Fri, 2 Jan 2026 14:02:50 +0100
Subject: [PATCH 02/11] Added Visitor to traverse AST to detemine access type
of expressions.
---
clang-tools-extra/clangd/ClangdLSPServer.cpp | 2 +-
clang-tools-extra/clangd/ClangdServer.cpp | 13 +-
clang-tools-extra/clangd/ClangdServer.h | 2 +-
clang-tools-extra/clangd/Protocol.cpp | 2 +-
clang-tools-extra/clangd/XRefs.cpp | 174 +++++++++---------
clang-tools-extra/clangd/XRefs.h | 2 +-
.../clangd/unittests/CallHierarchyTests.cpp | 137 +++++++++++---
7 files changed, 212 insertions(+), 120 deletions(-)
diff --git a/clang-tools-extra/clangd/ClangdLSPServer.cpp b/clang-tools-extra/clangd/ClangdLSPServer.cpp
index 1518f177b06a0..22aa6eeb581bd 100644
--- a/clang-tools-extra/clangd/ClangdLSPServer.cpp
+++ b/clang-tools-extra/clangd/ClangdLSPServer.cpp
@@ -1389,7 +1389,7 @@ void ClangdLSPServer::onPrepareCallHierarchy(
void ClangdLSPServer::onCallHierarchyIncomingCalls(
const CallHierarchyIncomingCallsParams &Params,
Callback<std::vector<CallHierarchyIncomingCall>> Reply) {
- Server->incomingCalls(Params.item, std::move(Reply));
+ Server->incomingCalls(Params.item.uri.file(), Params.item, std::move(Reply));
}
void ClangdLSPServer::onClangdInlayHints(const InlayHintsParams &Params,
diff --git a/clang-tools-extra/clangd/ClangdServer.cpp b/clang-tools-extra/clangd/ClangdServer.cpp
index ac1e9aa5f0ff1..4d8f3f4bd780d 100644
--- a/clang-tools-extra/clangd/ClangdServer.cpp
+++ b/clang-tools-extra/clangd/ClangdServer.cpp
@@ -908,12 +908,15 @@ void ClangdServer::prepareCallHierarchy(
}
void ClangdServer::incomingCalls(
- const CallHierarchyItem &Item,
+ PathRef File, const CallHierarchyItem &Item,
Callback<std::vector<CallHierarchyIncomingCall>> CB) {
- WorkScheduler->run("Incoming Calls", "",
- [CB = std::move(CB), Item, this]() mutable {
- CB(clangd::incomingCalls(Item, Index));
- });
+ auto Action = [Item, CB = std::move(CB),
+ this](llvm::Expected<InputsAndAST> InpAST) mutable {
+ if (!InpAST)
+ return CB(InpAST.takeError());
+ CB(clangd::incomingCalls(Item, Index, InpAST->AST));
+ };
+ WorkScheduler->runWithAST("Incoming Calls", File, std::move(Action));
}
void ClangdServer::inlayHints(PathRef File, std::optional<Range> RestrictRange,
diff --git a/clang-tools-extra/clangd/ClangdServer.h b/clang-tools-extra/clangd/ClangdServer.h
index d45d13fa034b5..20ca6bcc221d0 100644
--- a/clang-tools-extra/clangd/ClangdServer.h
+++ b/clang-tools-extra/clangd/ClangdServer.h
@@ -299,7 +299,7 @@ class ClangdServer {
Callback<std::vector<CallHierarchyItem>> CB);
/// Resolve incoming calls for a given call hierarchy item.
- void incomingCalls(const CallHierarchyItem &Item,
+ void incomingCalls(PathRef File, const CallHierarchyItem &Item,
Callback<std::vector<CallHierarchyIncomingCall>>);
/// Resolve outgoing calls for a given call hierarchy item.
diff --git a/clang-tools-extra/clangd/Protocol.cpp b/clang-tools-extra/clangd/Protocol.cpp
index 6027e60609fe2..7786f62b4347d 100644
--- a/clang-tools-extra/clangd/Protocol.cpp
+++ b/clang-tools-extra/clangd/Protocol.cpp
@@ -1496,7 +1496,7 @@ llvm::json::Value toJSON(const CallHierarchyItem &I) {
Result["data"] = I.data;
if (!I.referenceTags.empty())
Result["referenceTags"] = I.referenceTags;
-
+
return std::move(Result);
}
diff --git a/clang-tools-extra/clangd/XRefs.cpp b/clang-tools-extra/clangd/XRefs.cpp
index fd4dfe95213a5..d3dacee945ff7 100644
--- a/clang-tools-extra/clangd/XRefs.cpp
+++ b/clang-tools-extra/clangd/XRefs.cpp
@@ -1755,10 +1755,18 @@ class ParamUsageVisitor : public RecursiveASTVisitor<ParamUsageVisitor> {
public:
bool HasWrite = false;
bool HasRead = false;
- const ParmVarDecl *TargetParam;
+ const ValueDecl *TargetParam;
- ParamUsageVisitor(const ParmVarDecl *P) : TargetParam(P) {}
+ ParamUsageVisitor(const ValueDecl *P) : TargetParam(P) {}
+ // Any reference to the target is at least a read, unless we later
+ // identify it specifically as a write (e.g. assignment/inc/dec on LHS).
+ bool VisitDeclRefExpr(DeclRefExpr *DRE) {
+ if (DRE->getDecl() == TargetParam)
+ HasRead = true;
+ return true;
+ }
+
bool VisitUnaryOperator(UnaryOperator *UO) {
// Check for increment/decrement on parameter
if (UO->isIncrementDecrementOp()) {
@@ -1774,14 +1782,17 @@ class ParamUsageVisitor : public RecursiveASTVisitor<ParamUsageVisitor> {
bool VisitBinaryOperator(BinaryOperator *BO) {
// Check for assignment to parameter
if (BO->isAssignmentOp()) {
- if (auto *DRE = dyn_cast<DeclRefExpr>(BO->getLHS())) {
+ if (isa<DeclRefExpr>(BO->getLHS())) {
+ auto *DRE = dyn_cast<DeclRefExpr>(BO->getLHS());
if (DRE->getDecl() == TargetParam) {
HasWrite = true;
}
}
}
+
// Any other use is at least a read
- if (auto *DRE = dyn_cast<DeclRefExpr>(BO->getRHS())) {
+ if (isa<DeclRefExpr>(BO->getRHS())) {
+ auto *DRE = dyn_cast<DeclRefExpr>(BO->getRHS());
if (DRE->getDecl() == TargetParam) {
HasRead = true;
}
@@ -1790,90 +1801,25 @@ class ParamUsageVisitor : public RecursiveASTVisitor<ParamUsageVisitor> {
}
};
-static std::vector<ReferenceTag> analyseParameterUsage(const FunctionDecl *FD) {
+static std::vector<ReferenceTag> analyseParameterUsage(const FunctionDecl *FD,
+ const ValueDecl *PVD) {
std::vector<ReferenceTag> Result;
- // This requires more sophisticated analysis - checking if param is modified
const Stmt *Body = FD->getBody();
if (!Body)
return Result; // No definition available
- for (unsigned I = 0; I < FD->getNumParams(); ++I) {
- const ParmVarDecl *Param = FD->getParamDecl(I);
+ // Walk the body and determine read/write usage of the referenced variable
+ // within this function.
+ ParamUsageVisitor Visitor(PVD);
+ Visitor.TraverseStmt(const_cast<Stmt *>(Body));
+ if (Visitor.HasWrite)
+ Result.push_back(ReferenceTag::Write);
+ if (Visitor.HasRead)
+ Result.push_back(ReferenceTag::Read);
- // Check const qualifier
- // QualType ParamType = Param->getType();
- // bool IsReadOnly = ParamType.isConstQualified();
-
- // For deeper analysis, you'd need to:
- // 1. Walk the AST of the function body
- // 2. Find all references to the parameter
- // 3. Check if they appear on the left side of assignments (write)
- // or only on the right side (read)
-
- ParamUsageVisitor Visitor(Param);
- Visitor.TraverseStmt(const_cast<Stmt *>(Body));
- if (Visitor.HasWrite)
- Result.push_back(ReferenceTag::Write);
- if (Visitor.HasRead)
- Result.push_back(ReferenceTag::Read);
- }
return Result;
}
-template <typename HierarchyItem>
-static void determineParameterUsage(const NamedDecl &ND, HierarchyItem &HI) {
- // Get parent context and check if it's a function parameter
- const DeclContext *DC = ND.getDeclContext();
- elog("determineParameterUsage: called for ND={0}", ND.getNameAsString());
- if (const auto *TD = llvm::dyn_cast<TagDecl>(DC)) {
- elog("determineParameterUsage: ND is inside a TagDecl: {0}", TD->getNameAsString());
- // No parameter analysis for TagDecl parent contexts.
- } else if (const auto *FD = llvm::dyn_cast<FunctionDecl>(DC)) {
- elog("determineParameterUsage: ND is inside a FunctionDecl");
- for (unsigned I = 0; I < FD->getNumParams(); ++I) {
- if (FD->getParamDecl(I) == &ND) {
- elog("determineParameterUsage: ND is the {0}-th parameter of function {1}", I, FD->getNameAsString());
-
- const ParmVarDecl *Param = FD->getParamDecl(I);
- QualType ParamType = Param->getType();
-
- bool IsConst = false;
- bool IsConstRef = false;
- bool IsConstPtr = false;
-
- // Check if const (read-only)
- IsConst = ParamType.isConstQualified();
- elog("determineParameterUsage: ParamType.isConstQualified() = {0}", IsConst);
-
- // Check if it's a const reference
- if (const auto *RT = ParamType->getAs<ReferenceType>()) {
- IsConstRef = RT->getPointeeType().isConstQualified();
- elog("determineParameterUsage: ParamType is ReferenceType, isConstQualified = {0}", IsConstRef);
- }
-
- // Check if it's a const pointer
- if (const auto *PT = ParamType->getAs<PointerType>()) {
- IsConstPtr = PT->getPointeeType().isConstQualified();
- elog("determineParameterUsage: ParamType is PointerType, isConstQualified = {0}", IsConstPtr);
- }
-
- if (IsConst && IsConstRef && IsConstPtr) {
- elog("determineParameterUsage: All const checks passed, marking as Read");
- HI.referenceTags.push_back(ReferenceTag::Read);
- } else {
- elog("determineParameterUsage: Performing analyseParameterUsage");
- HI.referenceTags = analyseParameterUsage(FD);
- }
-
- break;
- }
- elog("determineParameterUsage: ND is not parameter {0} of function {1}", I, FD->getNameAsString());
- }
- } else {
- elog("determineParameterUsage: ND is not inside a FunctionDecl or TagDecl");
- }
-}
-
template <typename HierarchyItem>
static std::optional<HierarchyItem>
declToHierarchyItem(const NamedDecl &ND, llvm::StringRef TUPath) {
@@ -1904,7 +1850,7 @@ declToHierarchyItem(const NamedDecl &ND, llvm::StringRef TUPath) {
HierarchyItem HI;
HI.name = printName(Ctx, ND);
- // FIXME: Populate HI.detail the way we do in symbolToHierarchyItem?
+ HI.detail = printQualifiedName(ND);
HI.kind = SK;
HI.range = Range{sourceLocToPosition(SM, DeclRange->getBegin()),
sourceLocToPosition(SM, DeclRange->getEnd())};
@@ -1915,7 +1861,7 @@ declToHierarchyItem(const NamedDecl &ND, llvm::StringRef TUPath) {
HI.range = HI.selectionRange;
}
- determineParameterUsage(ND, HI);
+ //determineParameterUsage(ND, HI);
HI.uri = URIForFile::canonicalize(*FilePath, TUPath);
@@ -2464,8 +2410,38 @@ prepareCallHierarchy(ParsedAST &AST, Position Pos, PathRef TUPath) {
return Result;
}
+// Tries to find a NamedDecl in the AST that matches the given Symbol.
+// Returns nullptr if the symbol is not found in the current AST.
+const NamedDecl *getNamedDeclFromSymbol(const Symbol &Sym,
+ const ParsedAST &AST) {
+ // Try to convert the symbol to a location and find the decl at that location
+ auto SymLoc = symbolToLocation(Sym, AST.tuPath());
+ if (!SymLoc)
+ return nullptr;
+
+ // Check if the symbol location is in the main file
+ if (SymLoc->uri.file() != AST.tuPath())
+ return nullptr;
+
+ // Convert LSP position to source location
+ const auto &SM = AST.getSourceManager();
+ auto CurLoc = sourceLocationInMainFile(SM, SymLoc->range.start);
+ if (!CurLoc) {
+ llvm::consumeError(CurLoc.takeError());
+ return nullptr;
+ }
+
+ // Get all decls at this location
+ auto Decls = getDeclAtPosition(const_cast<ParsedAST &>(AST), *CurLoc, {});
+ if (Decls.empty())
+ return nullptr;
+
+ // Return the first decl (usually the most specific one)
+ return Decls[0];
+}
+
std::vector<CallHierarchyIncomingCall>
-incomingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index) {
+incomingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index, ParsedAST &AST) {
std::vector<CallHierarchyIncomingCall> Results;
if (!Index || Item.data.empty())
return Results;
@@ -2474,6 +2450,24 @@ incomingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index) {
elog("incomingCalls failed to find symbol: {0}", ID.takeError());
return Results;
}
+
+
+ LookupRequest LR;
+ LR.IDs.insert(*ID);
+
+ std::optional<const NamedDecl*> PVD;
+ Index->lookup(LR, [&ID, &AST, &PVD](const Symbol &Sym) {
+ // This callback is called once per found symbol; here we expect exactly one
+ if (Sym.ID == *ID) {
+ PVD = getNamedDeclFromSymbol(Sym, AST);
+ }
+ });
+
+ if (PVD == nullptr || !PVD.has_value()) {
+ // Not found in index
+ return Results;
+ }
+
// In this function, we find incoming calls based on the index only.
// In principle, the AST could have more up-to-date information about
// occurrences within the current file. However, going from a SymbolID
@@ -2510,7 +2504,21 @@ incomingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index) {
Index->lookup(ContainerLookup, [&](const Symbol &Caller) {
auto It = CallsIn.find(Caller.ID);
assert(It != CallsIn.end());
- if (auto CHI = symbolToCallHierarchyItem(Caller, Item.uri.file())) {
+
+ std::optional<CallHierarchyItem> CHI;
+ if (auto *ND = getNamedDeclFromSymbol(Caller, AST)) {
+ CHI = declToCallHierarchyItem(*ND, AST.tuPath());
+ if (const auto *FD = llvm::dyn_cast<clang::FunctionDecl>(ND)) {
+ if (isa<ValueDecl>(PVD.value())) {
+ const auto *VD = llvm::dyn_cast<clang::ValueDecl>(PVD.value());
+ CHI->referenceTags = analyseParameterUsage(FD, VD); // FD is the caller of var
+ }
+ }
+ } else {
+ CHI = symbolToCallHierarchyItem(Caller, Item.uri.file());
+ }
+
+ if (CHI) {
std::vector<Range> FromRanges;
for (const Location &L : It->second) {
if (L.uri != CHI->uri) {
diff --git a/clang-tools-extra/clangd/XRefs.h b/clang-tools-extra/clangd/XRefs.h
index 247e52314c3f9..911cf72d72f03 100644
--- a/clang-tools-extra/clangd/XRefs.h
+++ b/clang-tools-extra/clangd/XRefs.h
@@ -148,7 +148,7 @@ std::vector<CallHierarchyItem>
prepareCallHierarchy(ParsedAST &AST, Position Pos, PathRef TUPath);
std::vector<CallHierarchyIncomingCall>
-incomingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index);
+incomingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index, ParsedAST &AST);
std::vector<CallHierarchyOutgoingCall>
outgoingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index);
diff --git a/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp b/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp
index 9859577c7cf7e..ad5c7d06a0739 100644
--- a/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp
+++ b/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp
@@ -89,12 +89,12 @@ TEST(CallHierarchy, IncomingOneFileCpp) {
std::vector<CallHierarchyItem> Items =
prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
ASSERT_THAT(Items, ElementsAre(withName("callee")));
- auto IncomingLevel1 = incomingCalls(Items[0], Index.get());
+ auto IncomingLevel1 = incomingCalls(Items[0], Index.get(), AST);
ASSERT_THAT(
IncomingLevel1,
ElementsAre(AllOf(from(AllOf(withName("caller1"), withDetail("caller1"))),
iFromRanges(Source.range("Callee")))));
- auto IncomingLevel2 = incomingCalls(IncomingLevel1[0].from, Index.get());
+ auto IncomingLevel2 = incomingCalls(IncomingLevel1[0].from, Index.get(), AST);
ASSERT_THAT(
IncomingLevel2,
ElementsAre(AllOf(from(AllOf(withName("caller2"), withDetail("caller2"))),
@@ -103,13 +103,13 @@ TEST(CallHierarchy, IncomingOneFileCpp) {
AllOf(from(AllOf(withName("caller3"), withDetail("caller3"))),
iFromRanges(Source.range("Caller1C")))));
- auto IncomingLevel3 = incomingCalls(IncomingLevel2[0].from, Index.get());
+ auto IncomingLevel3 = incomingCalls(IncomingLevel2[0].from, Index.get(), AST);
ASSERT_THAT(
IncomingLevel3,
ElementsAre(AllOf(from(AllOf(withName("caller3"), withDetail("caller3"))),
iFromRanges(Source.range("Caller2")))));
- auto IncomingLevel4 = incomingCalls(IncomingLevel3[0].from, Index.get());
+ auto IncomingLevel4 = incomingCalls(IncomingLevel3[0].from, Index.get(), AST);
EXPECT_THAT(IncomingLevel4, IsEmpty());
}
@@ -137,12 +137,12 @@ TEST(CallHierarchy, IncomingOneFileObjC) {
std::vector<CallHierarchyItem> Items =
prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
ASSERT_THAT(Items, ElementsAre(withName("callee")));
- auto IncomingLevel1 = incomingCalls(Items[0], Index.get());
+ auto IncomingLevel1 = incomingCalls(Items[0], Index.get(), AST);
ASSERT_THAT(IncomingLevel1,
ElementsAre(AllOf(from(AllOf(withName("caller1"),
withDetail("MyClass::caller1"))),
iFromRanges(Source.range("Callee")))));
- auto IncomingLevel2 = incomingCalls(IncomingLevel1[0].from, Index.get());
+ auto IncomingLevel2 = incomingCalls(IncomingLevel1[0].from, Index.get(), AST);
ASSERT_THAT(IncomingLevel2,
ElementsAre(AllOf(from(AllOf(withName("caller2"),
withDetail("MyClass::caller2"))),
@@ -152,13 +152,13 @@ TEST(CallHierarchy, IncomingOneFileObjC) {
withDetail("MyClass::caller3"))),
iFromRanges(Source.range("Caller1C")))));
- auto IncomingLevel3 = incomingCalls(IncomingLevel2[0].from, Index.get());
+ auto IncomingLevel3 = incomingCalls(IncomingLevel2[0].from, Index.get(), AST);
ASSERT_THAT(IncomingLevel3,
ElementsAre(AllOf(from(AllOf(withName("caller3"),
withDetail("MyClass::caller3"))),
iFromRanges(Source.range("Caller2")))));
- auto IncomingLevel4 = incomingCalls(IncomingLevel3[0].from, Index.get());
+ auto IncomingLevel4 = incomingCalls(IncomingLevel3[0].from, Index.get(), AST);
EXPECT_THAT(IncomingLevel4, IsEmpty());
}
@@ -184,18 +184,18 @@ TEST(CallHierarchy, IncomingIncludeOverrides) {
std::vector<CallHierarchyItem> Items =
prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
ASSERT_THAT(Items, ElementsAre(withName("callee")));
- auto IncomingLevel1 = incomingCalls(Items[0], Index.get());
+ auto IncomingLevel1 = incomingCalls(Items[0], Index.get(), AST);
ASSERT_THAT(IncomingLevel1,
ElementsAre(AllOf(from(AllOf(withName("Func"),
withDetail("Implementation::Func"))),
iFromRanges(Source.range("Callee")))));
- auto IncomingLevel2 = incomingCalls(IncomingLevel1[0].from, Index.get());
+ auto IncomingLevel2 = incomingCalls(IncomingLevel1[0].from, Index.get(), AST);
ASSERT_THAT(
IncomingLevel2,
ElementsAre(AllOf(from(AllOf(withName("Test"), withDetail("Test"))),
iFromRanges(Source.range("FuncCall")))));
- auto IncomingLevel3 = incomingCalls(IncomingLevel2[0].from, Index.get());
+ auto IncomingLevel3 = incomingCalls(IncomingLevel2[0].from, Index.get(), AST);
EXPECT_THAT(IncomingLevel3, IsEmpty());
}
@@ -221,13 +221,13 @@ TEST(CallHierarchy, MainFileOnlyRef) {
std::vector<CallHierarchyItem> Items =
prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
ASSERT_THAT(Items, ElementsAre(withName("callee")));
- auto IncomingLevel1 = incomingCalls(Items[0], Index.get());
+ auto IncomingLevel1 = incomingCalls(Items[0], Index.get(), AST);
ASSERT_THAT(
IncomingLevel1,
ElementsAre(AllOf(from(AllOf(withName("caller1"), withDetail("caller1"))),
iFromRanges(Source.range("Callee")))));
- auto IncomingLevel2 = incomingCalls(IncomingLevel1[0].from, Index.get());
+ auto IncomingLevel2 = incomingCalls(IncomingLevel1[0].from, Index.get(), AST);
EXPECT_THAT(
IncomingLevel2,
ElementsAre(AllOf(from(AllOf(withName("caller2"), withDetail("caller2"))),
@@ -256,7 +256,7 @@ TEST(CallHierarchy, IncomingQualified) {
std::vector<CallHierarchyItem> Items =
prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
ASSERT_THAT(Items, ElementsAre(withName("Waldo::find")));
- auto Incoming = incomingCalls(Items[0], Index.get());
+ auto Incoming = incomingCalls(Items[0], Index.get(), AST);
EXPECT_THAT(
Incoming,
ElementsAre(
@@ -396,13 +396,13 @@ TEST(CallHierarchy, MultiFileCpp) {
std::vector<CallHierarchyItem> Items =
prepareCallHierarchy(AST, Pos, TUPath);
ASSERT_THAT(Items, ElementsAre(withName("callee")));
- auto IncomingLevel1 = incomingCalls(Items[0], Index.get());
+ auto IncomingLevel1 = incomingCalls(Items[0], Index.get(), AST);
ASSERT_THAT(IncomingLevel1,
ElementsAre(AllOf(from(AllOf(withName("caller1"),
withDetail("nsa::caller1"))),
iFromRanges(Caller1C.range()))));
- auto IncomingLevel2 = incomingCalls(IncomingLevel1[0].from, Index.get());
+ auto IncomingLevel2 = incomingCalls(IncomingLevel1[0].from, Index.get(), AST);
ASSERT_THAT(
IncomingLevel2,
ElementsAre(
@@ -411,13 +411,13 @@ TEST(CallHierarchy, MultiFileCpp) {
AllOf(from(AllOf(withName("caller3"), withDetail("nsa::caller3"))),
iFromRanges(Caller3C.range("Caller1")))));
- auto IncomingLevel3 = incomingCalls(IncomingLevel2[0].from, Index.get());
+ auto IncomingLevel3 = incomingCalls(IncomingLevel2[0].from, Index.get(), AST);
ASSERT_THAT(IncomingLevel3,
ElementsAre(AllOf(from(AllOf(withName("caller3"),
withDetail("nsa::caller3"))),
iFromRanges(Caller3C.range("Caller2")))));
- auto IncomingLevel4 = incomingCalls(IncomingLevel3[0].from, Index.get());
+ auto IncomingLevel4 = incomingCalls(IncomingLevel3[0].from, Index.get(), AST);
EXPECT_THAT(IncomingLevel4, IsEmpty());
};
@@ -553,12 +553,12 @@ TEST(CallHierarchy, IncomingMultiFileObjC) {
std::vector<CallHierarchyItem> Items =
prepareCallHierarchy(AST, Pos, TUPath);
ASSERT_THAT(Items, ElementsAre(withName("callee")));
- auto IncomingLevel1 = incomingCalls(Items[0], Index.get());
+ auto IncomingLevel1 = incomingCalls(Items[0], Index.get(), AST);
ASSERT_THAT(IncomingLevel1,
ElementsAre(AllOf(from(withName("caller1")),
iFromRanges(Caller1C.range()))));
- auto IncomingLevel2 = incomingCalls(IncomingLevel1[0].from, Index.get());
+ auto IncomingLevel2 = incomingCalls(IncomingLevel1[0].from, Index.get(), AST);
ASSERT_THAT(IncomingLevel2,
ElementsAre(AllOf(from(withName("caller2")),
iFromRanges(Caller2C.range("A"),
@@ -566,12 +566,12 @@ TEST(CallHierarchy, IncomingMultiFileObjC) {
AllOf(from(withName("caller3")),
iFromRanges(Caller3C.range("Caller1")))));
- auto IncomingLevel3 = incomingCalls(IncomingLevel2[0].from, Index.get());
+ auto IncomingLevel3 = incomingCalls(IncomingLevel2[0].from, Index.get(), AST);
ASSERT_THAT(IncomingLevel3,
ElementsAre(AllOf(from(withName("caller3")),
iFromRanges(Caller3C.range("Caller2")))));
- auto IncomingLevel4 = incomingCalls(IncomingLevel3[0].from, Index.get());
+ auto IncomingLevel4 = incomingCalls(IncomingLevel3[0].from, Index.get(), AST);
EXPECT_THAT(IncomingLevel4, IsEmpty());
};
@@ -616,7 +616,7 @@ TEST(CallHierarchy, CallInLocalVarDecl) {
prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
ASSERT_THAT(Items, ElementsAre(withName("callee")));
- auto Incoming = incomingCalls(Items[0], Index.get());
+ auto Incoming = incomingCalls(Items[0], Index.get(), AST);
ASSERT_THAT(Incoming, ElementsAre(AllOf(from(withName("caller1")),
iFromRanges(Source.range("call1"))),
AllOf(from(withName("caller2")),
@@ -643,7 +643,7 @@ TEST(CallHierarchy, HierarchyOnField) {
std::vector<CallHierarchyItem> Items =
prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
ASSERT_THAT(Items, ElementsAre(withName("var1")));
- auto IncomingLevel1 = incomingCalls(Items[0], Index.get());
+ auto IncomingLevel1 = incomingCalls(Items[0], Index.get(), AST);
ASSERT_THAT(IncomingLevel1,
ElementsAre(AllOf(from(withName("caller")),
iFromRanges(Source.range("Callee")))));
@@ -664,12 +664,93 @@ TEST(CallHierarchy, HierarchyOnVar) {
std::vector<CallHierarchyItem> Items =
prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
ASSERT_THAT(Items, ElementsAre(withName("var")));
- auto IncomingLevel1 = incomingCalls(Items[0], Index.get());
+ auto IncomingLevel1 = incomingCalls(Items[0], Index.get(), AST);
ASSERT_THAT(IncomingLevel1,
ElementsAre(AllOf(from(withName("caller")),
iFromRanges(Source.range("Callee")))));
}
+TEST(CallHierarchy, HierarchyOnVarWithReadReference) {
+ // Tests that the call hierarchy works on non-local variables and read/write tags are set.
+ Annotations Source(R"cpp(
+ int v^ar = 1;
+ void caller() {
+ int x = 0;
+ x = var;
+ }
+ )cpp");
+ TestTU TU = TestTU::withCode(Source.code());
+ auto AST = TU.build();
+ auto Index = TU.index();
+
+ std::vector<CallHierarchyItem> Items =
+ prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
+ ASSERT_THAT(Items, ElementsAre(withName("var")));
+ auto IncomingLevel1 = incomingCalls(Items[0], Index.get(), AST);
+ EXPECT_TRUE(IncomingLevel1.front().from.referenceTags.at(0) == ReferenceTag::Read);
+}
+
+TEST(CallHierarchy, HierarchyOnVarWithWriteReference) {
+ // Tests that the call hierarchy works on non-local variables and read/write tags are set.
+ Annotations Source(R"cpp(
+ int v^ar = 1;
+ void caller() {
+ var = 2;
+ }
+ )cpp");
+ TestTU TU = TestTU::withCode(Source.code());
+ auto AST = TU.build();
+ auto Index = TU.index();
+
+ std::vector<CallHierarchyItem> Items =
+ prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
+ ASSERT_THAT(Items, ElementsAre(withName("var")));
+ auto IncomingLevel1 = incomingCalls(Items[0], Index.get(), AST);
+ EXPECT_TRUE(IncomingLevel1.front().from.referenceTags.at(0) == ReferenceTag::Write);
+}
+
+TEST(CallHierarchy, HierarchyOnVarWithUnaryWriteReference) {
+ // Tests that the call hierarchy works on non-local variables and read/write tags are set.
+ Annotations Source(R"cpp(
+ int v^ar = 1;
+ void caller() {
+ var++;
+ }
+ )cpp");
+ TestTU TU = TestTU::withCode(Source.code());
+ auto AST = TU.build();
+ auto Index = TU.index();
+
+ std::vector<CallHierarchyItem> Items =
+ prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
+ ASSERT_THAT(Items, ElementsAre(withName("var")));
+ auto IncomingLevel1 = incomingCalls(Items[0], Index.get(), AST);
+ EXPECT_TRUE(IncomingLevel1.front().from.referenceTags.at(0) == ReferenceTag::Write);
+}
+
+// TEST(CallHierarchy, HierarchyOnFieldWithReadWriteReference) {
+// // Tests that the call hierarchy works on non-local variables and read/write tags are set.
+// Annotations Source(R"cpp(
+// struct Vars {
+// int v^ar1 = 1;
+// };
+// void caller() {
+// Vars values;
+// values.var1 = 2;
+// }
+// )cpp");
+// TestTU TU = TestTU::withCode(Source.code());
+// auto AST = TU.build();
+// auto Index = TU.index();
+//
+// std::vector<CallHierarchyItem> Items =
+// prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
+// ASSERT_THAT(Items, ElementsAre(withName("var1")));
+// auto IncomingLevel1 = incomingCalls(Items[0], Index.get(), AST);
+// EXPECT_TRUE(IncomingLevel1.front().from.referenceTags.at(0) == ReferenceTag::Read);
+// //EXPECT_TRUE(IncomingLevel1.front().from.referenceTags.at(1) == ReferenceTag::Read);
+// }
+
TEST(CallHierarchy, HierarchyOnEnumConstant) {
// Tests that the call hierarchy works on enum constants.
Annotations Source(R"cpp(
@@ -686,14 +767,14 @@ TEST(CallHierarchy, HierarchyOnEnumConstant) {
std::vector<CallHierarchyItem> Items =
prepareCallHierarchy(AST, Source.point("Heads"), testPath(TU.Filename));
ASSERT_THAT(Items, ElementsAre(withName("heads")));
- auto IncomingLevel1 = incomingCalls(Items[0], Index.get());
+ auto IncomingLevel1 = incomingCalls(Items[0], Index.get(), AST);
ASSERT_THAT(IncomingLevel1,
ElementsAre(AllOf(from(withName("caller")),
iFromRanges(Source.range("CallerH")))));
Items =
prepareCallHierarchy(AST, Source.point("Tails"), testPath(TU.Filename));
ASSERT_THAT(Items, ElementsAre(withName("tails")));
- IncomingLevel1 = incomingCalls(Items[0], Index.get());
+ IncomingLevel1 = incomingCalls(Items[0], Index.get(), AST);
ASSERT_THAT(IncomingLevel1,
ElementsAre(AllOf(from(withName("caller")),
iFromRanges(Source.range("CallerT")))));
@@ -718,7 +799,7 @@ TEST(CallHierarchy, CallInDifferentFileThanCaller) {
prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
ASSERT_THAT(Items, ElementsAre(withName("callee")));
- auto Incoming = incomingCalls(Items[0], Index.get());
+ auto Incoming = incomingCalls(Items[0], Index.get(), AST);
// The only call site is in the source file, which is a different file from
// the declaration of the function containing the call, which is in the
>From 98e1167c36c1b4a3b62b779c3647d9ea6e99606a Mon Sep 17 00:00:00 2001
From: Dimitri Ratz <dimitri.ratz at thinkdigital.cc>
Date: Thu, 29 Jan 2026 19:09:15 +0100
Subject: [PATCH 03/11] Fix Decl check.
- Fix lit tests
- Fix unit tests.
---
clang-tools-extra/clangd/XRefs.cpp | 34 +++++----
clang-tools-extra/clangd/XRefs.h | 3 +-
.../clangd/test/call-hierarchy.test | 1 +
.../clangd/test/type-hierarchy-ext.test | 3 +
.../clangd/test/type-hierarchy.test | 1 +
.../clangd/unittests/CallHierarchyTests.cpp | 74 ++++++++++---------
6 files changed, 63 insertions(+), 53 deletions(-)
diff --git a/clang-tools-extra/clangd/XRefs.cpp b/clang-tools-extra/clangd/XRefs.cpp
index d3dacee945ff7..69947c77238f6 100644
--- a/clang-tools-extra/clangd/XRefs.cpp
+++ b/clang-tools-extra/clangd/XRefs.cpp
@@ -68,7 +68,6 @@
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/raw_ostream.h"
-#include "support/Logger.h"
#include <algorithm>
#include <optional>
#include <string>
@@ -1756,9 +1755,9 @@ class ParamUsageVisitor : public RecursiveASTVisitor<ParamUsageVisitor> {
bool HasWrite = false;
bool HasRead = false;
const ValueDecl *TargetParam;
-
+
ParamUsageVisitor(const ValueDecl *P) : TargetParam(P) {}
-
+
// Any reference to the target is at least a read, unless we later
// identify it specifically as a write (e.g. assignment/inc/dec on LHS).
bool VisitDeclRefExpr(DeclRefExpr *DRE) {
@@ -1778,7 +1777,6 @@ class ParamUsageVisitor : public RecursiveASTVisitor<ParamUsageVisitor> {
}
return true;
}
-
bool VisitBinaryOperator(BinaryOperator *BO) {
// Check for assignment to parameter
if (BO->isAssignmentOp()) {
@@ -1861,8 +1859,6 @@ declToHierarchyItem(const NamedDecl &ND, llvm::StringRef TUPath) {
HI.range = HI.selectionRange;
}
- //determineParameterUsage(ND, HI);
-
HI.uri = URIForFile::canonicalize(*FilePath, TUPath);
return HI;
@@ -2441,7 +2437,8 @@ const NamedDecl *getNamedDeclFromSymbol(const Symbol &Sym,
}
std::vector<CallHierarchyIncomingCall>
-incomingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index, ParsedAST &AST) {
+incomingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index,
+ ParsedAST &AST) {
std::vector<CallHierarchyIncomingCall> Results;
if (!Index || Item.data.empty())
return Results;
@@ -2451,20 +2448,22 @@ incomingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index, ParsedAST
return Results;
}
-
LookupRequest LR;
LR.IDs.insert(*ID);
- std::optional<const NamedDecl*> PVD;
- Index->lookup(LR, [&ID, &AST, &PVD](const Symbol &Sym) {
+ std::optional<const NamedDecl *> Decl;
+ Index->lookup(LR, [&ID, &AST, &Decl](const Symbol &Sym) {
// This callback is called once per found symbol; here we expect exactly one
if (Sym.ID == *ID) {
- PVD = getNamedDeclFromSymbol(Sym, AST);
+ Decl = getNamedDeclFromSymbol(Sym, AST);
}
});
- if (PVD == nullptr || !PVD.has_value()) {
- // Not found in index
+ // Note: Decl may be nullptr if the symbol is in a header file (not the main
+ // file). In that case, we still want to continue and use index-based
+ // resolution.
+ if (!Decl.has_value()) {
+ // Symbol not found in index
return Results;
}
@@ -2509,9 +2508,12 @@ incomingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index, ParsedAST
if (auto *ND = getNamedDeclFromSymbol(Caller, AST)) {
CHI = declToCallHierarchyItem(*ND, AST.tuPath());
if (const auto *FD = llvm::dyn_cast<clang::FunctionDecl>(ND)) {
- if (isa<ValueDecl>(PVD.value())) {
- const auto *VD = llvm::dyn_cast<clang::ValueDecl>(PVD.value());
- CHI->referenceTags = analyseParameterUsage(FD, VD); // FD is the caller of var
+ if (Decl.has_value() && Decl.value() != nullptr) {
+ if (const auto *VD =
+ llvm::dyn_cast<clang::ValueDecl>(Decl.value())) {
+ CHI->referenceTags =
+ analyseParameterUsage(FD, VD); // FD is the caller of var
+ }
}
}
} else {
diff --git a/clang-tools-extra/clangd/XRefs.h b/clang-tools-extra/clangd/XRefs.h
index 911cf72d72f03..31e7b0b14440f 100644
--- a/clang-tools-extra/clangd/XRefs.h
+++ b/clang-tools-extra/clangd/XRefs.h
@@ -148,7 +148,8 @@ std::vector<CallHierarchyItem>
prepareCallHierarchy(ParsedAST &AST, Position Pos, PathRef TUPath);
std::vector<CallHierarchyIncomingCall>
-incomingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index, ParsedAST &AST);
+incomingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index,
+ ParsedAST &AST);
std::vector<CallHierarchyOutgoingCall>
outgoingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index);
diff --git a/clang-tools-extra/clangd/test/call-hierarchy.test b/clang-tools-extra/clangd/test/call-hierarchy.test
index 6548ea0068a8d..44c89d22d9c85 100644
--- a/clang-tools-extra/clangd/test/call-hierarchy.test
+++ b/clang-tools-extra/clangd/test/call-hierarchy.test
@@ -9,6 +9,7 @@
# CHECK-NEXT: "result": [
# CHECK-NEXT: {
# CHECK-NEXT: "data": "{{.*}}",
+# CHECK-NEXT: "detail": "callee",
# CHECK-NEXT: "kind": 12,
# CHECK-NEXT: "name": "callee",
# CHECK-NEXT: "range": {
diff --git a/clang-tools-extra/clangd/test/type-hierarchy-ext.test b/clang-tools-extra/clangd/test/type-hierarchy-ext.test
index 8d1a5dc31da0f..983c7538088bf 100644
--- a/clang-tools-extra/clangd/test/type-hierarchy-ext.test
+++ b/clang-tools-extra/clangd/test/type-hierarchy-ext.test
@@ -52,6 +52,7 @@
# CHECK-NEXT: ],
# CHECK-NEXT: "symbolID": "8A991335E4E67D08"
# CHECK-NEXT: },
+# CHECK-NEXT: "detail": "Child2",
# CHECK-NEXT: "kind": 23,
# CHECK-NEXT: "name": "Child2",
# CHECK-NEXT: "parents": [
@@ -65,6 +66,7 @@
# CHECK-NEXT: ],
# CHECK-NEXT: "symbolID": "ECDC0C46D75120F4"
# CHECK-NEXT: },
+# CHECK-NEXT: "detail": "Child1",
# CHECK-NEXT: "kind": 23,
# CHECK-NEXT: "name": "Child1",
# CHECK-NEXT: "parents": [
@@ -73,6 +75,7 @@
# CHECK-NEXT: "parents": [],
# CHECK-NEXT: "symbolID": "FE546E7B648D69A7"
# CHECK-NEXT: },
+# CHECK-NEXT: "detail": "Parent",
# CHECK-NEXT: "kind": 23,
# CHECK-NEXT: "name": "Parent",
# CHECK-NEXT: "parents": [],
diff --git a/clang-tools-extra/clangd/test/type-hierarchy.test b/clang-tools-extra/clangd/test/type-hierarchy.test
index a5f13ab13d0b3..cf52f7af1ec61 100644
--- a/clang-tools-extra/clangd/test/type-hierarchy.test
+++ b/clang-tools-extra/clangd/test/type-hierarchy.test
@@ -22,6 +22,7 @@
# CHECK-NEXT: ],
# CHECK-NEXT: "symbolID": "8A991335E4E67D08"
# CHECK-NEXT: },
+# CHECK-NEXT: "detail": "Child2",
# CHECK-NEXT: "kind": 23,
# CHECK-NEXT: "name": "Child2",
# CHECK-NEXT: "range": {
diff --git a/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp b/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp
index ad5c7d06a0739..15387b10aad50 100644
--- a/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp
+++ b/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp
@@ -67,6 +67,12 @@ ::testing::Matcher<CallHierarchyOutgoingCall> oFromRanges(RangeMatchers... M) {
UnorderedElementsAre(M...));
}
+template <typename... References>
+::testing::Matcher<CallHierarchyItem> withReferenceTags(References... refs) {
+ return Field(&CallHierarchyItem::referenceTags,
+ UnorderedElementsAre(refs...));
+}
+
TEST(CallHierarchy, IncomingOneFileCpp) {
Annotations Source(R"cpp(
void call^ee(int);
@@ -402,7 +408,8 @@ TEST(CallHierarchy, MultiFileCpp) {
withDetail("nsa::caller1"))),
iFromRanges(Caller1C.range()))));
- auto IncomingLevel2 = incomingCalls(IncomingLevel1[0].from, Index.get(), AST);
+ auto IncomingLevel2 =
+ incomingCalls(IncomingLevel1[0].from, Index.get(), AST);
ASSERT_THAT(
IncomingLevel2,
ElementsAre(
@@ -411,13 +418,15 @@ TEST(CallHierarchy, MultiFileCpp) {
AllOf(from(AllOf(withName("caller3"), withDetail("nsa::caller3"))),
iFromRanges(Caller3C.range("Caller1")))));
- auto IncomingLevel3 = incomingCalls(IncomingLevel2[0].from, Index.get(), AST);
+ auto IncomingLevel3 =
+ incomingCalls(IncomingLevel2[0].from, Index.get(), AST);
ASSERT_THAT(IncomingLevel3,
ElementsAre(AllOf(from(AllOf(withName("caller3"),
withDetail("nsa::caller3"))),
iFromRanges(Caller3C.range("Caller2")))));
- auto IncomingLevel4 = incomingCalls(IncomingLevel3[0].from, Index.get(), AST);
+ auto IncomingLevel4 =
+ incomingCalls(IncomingLevel3[0].from, Index.get(), AST);
EXPECT_THAT(IncomingLevel4, IsEmpty());
};
@@ -558,7 +567,8 @@ TEST(CallHierarchy, IncomingMultiFileObjC) {
ElementsAre(AllOf(from(withName("caller1")),
iFromRanges(Caller1C.range()))));
- auto IncomingLevel2 = incomingCalls(IncomingLevel1[0].from, Index.get(), AST);
+ auto IncomingLevel2 =
+ incomingCalls(IncomingLevel1[0].from, Index.get(), AST);
ASSERT_THAT(IncomingLevel2,
ElementsAre(AllOf(from(withName("caller2")),
iFromRanges(Caller2C.range("A"),
@@ -566,12 +576,14 @@ TEST(CallHierarchy, IncomingMultiFileObjC) {
AllOf(from(withName("caller3")),
iFromRanges(Caller3C.range("Caller1")))));
- auto IncomingLevel3 = incomingCalls(IncomingLevel2[0].from, Index.get(), AST);
+ auto IncomingLevel3 =
+ incomingCalls(IncomingLevel2[0].from, Index.get(), AST);
ASSERT_THAT(IncomingLevel3,
ElementsAre(AllOf(from(withName("caller3")),
iFromRanges(Caller3C.range("Caller2")))));
- auto IncomingLevel4 = incomingCalls(IncomingLevel3[0].from, Index.get(), AST);
+ auto IncomingLevel4 =
+ incomingCalls(IncomingLevel3[0].from, Index.get(), AST);
EXPECT_THAT(IncomingLevel4, IsEmpty());
};
@@ -671,7 +683,8 @@ TEST(CallHierarchy, HierarchyOnVar) {
}
TEST(CallHierarchy, HierarchyOnVarWithReadReference) {
- // Tests that the call hierarchy works on non-local variables and read/write tags are set.
+ // Tests that the call hierarchy works on non-local variables and a read is
+ // set.
Annotations Source(R"cpp(
int v^ar = 1;
void caller() {
@@ -687,11 +700,14 @@ TEST(CallHierarchy, HierarchyOnVarWithReadReference) {
prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
ASSERT_THAT(Items, ElementsAre(withName("var")));
auto IncomingLevel1 = incomingCalls(Items[0], Index.get(), AST);
- EXPECT_TRUE(IncomingLevel1.front().from.referenceTags.at(0) == ReferenceTag::Read);
+ ASSERT_FALSE(IncomingLevel1.empty());
+ EXPECT_THAT(
+ IncomingLevel1,
+ ElementsAre(AllOf(from(
+ AllOf(withName("caller"), withReferenceTags(ReferenceTag::Read))))));
}
TEST(CallHierarchy, HierarchyOnVarWithWriteReference) {
- // Tests that the call hierarchy works on non-local variables and read/write tags are set.
Annotations Source(R"cpp(
int v^ar = 1;
void caller() {
@@ -706,11 +722,15 @@ TEST(CallHierarchy, HierarchyOnVarWithWriteReference) {
prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
ASSERT_THAT(Items, ElementsAre(withName("var")));
auto IncomingLevel1 = incomingCalls(Items[0], Index.get(), AST);
- EXPECT_TRUE(IncomingLevel1.front().from.referenceTags.at(0) == ReferenceTag::Write);
+ ASSERT_FALSE(IncomingLevel1.empty());
+ EXPECT_THAT(
+ IncomingLevel1,
+ ElementsAre(AllOf(from(
+ AllOf(withName("caller"),
+ withReferenceTags(ReferenceTag::Write, ReferenceTag::Read))))));
}
-TEST(CallHierarchy, HierarchyOnVarWithUnaryWriteReference) {
- // Tests that the call hierarchy works on non-local variables and read/write tags are set.
+TEST(CallHierarchy, HierarchyOnVarWithUnaryReadWriteReference) {
Annotations Source(R"cpp(
int v^ar = 1;
void caller() {
@@ -725,32 +745,14 @@ TEST(CallHierarchy, HierarchyOnVarWithUnaryWriteReference) {
prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
ASSERT_THAT(Items, ElementsAre(withName("var")));
auto IncomingLevel1 = incomingCalls(Items[0], Index.get(), AST);
- EXPECT_TRUE(IncomingLevel1.front().from.referenceTags.at(0) == ReferenceTag::Write);
+ ASSERT_FALSE(IncomingLevel1.empty());
+ EXPECT_THAT(
+ IncomingLevel1,
+ UnorderedElementsAre(AllOf(from(
+ AllOf(withName("caller"),
+ withReferenceTags(ReferenceTag::Write, ReferenceTag::Read))))));
}
-// TEST(CallHierarchy, HierarchyOnFieldWithReadWriteReference) {
-// // Tests that the call hierarchy works on non-local variables and read/write tags are set.
-// Annotations Source(R"cpp(
-// struct Vars {
-// int v^ar1 = 1;
-// };
-// void caller() {
-// Vars values;
-// values.var1 = 2;
-// }
-// )cpp");
-// TestTU TU = TestTU::withCode(Source.code());
-// auto AST = TU.build();
-// auto Index = TU.index();
-//
-// std::vector<CallHierarchyItem> Items =
-// prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
-// ASSERT_THAT(Items, ElementsAre(withName("var1")));
-// auto IncomingLevel1 = incomingCalls(Items[0], Index.get(), AST);
-// EXPECT_TRUE(IncomingLevel1.front().from.referenceTags.at(0) == ReferenceTag::Read);
-// //EXPECT_TRUE(IncomingLevel1.front().from.referenceTags.at(1) == ReferenceTag::Read);
-// }
-
TEST(CallHierarchy, HierarchyOnEnumConstant) {
// Tests that the call hierarchy works on enum constants.
Annotations Source(R"cpp(
>From 37759683319008b27bc89626f8224aa3d640554f Mon Sep 17 00:00:00 2001
From: Dimitri Ratz <dimitri.ratz at thinkdigital.cc>
Date: Mon, 2 Feb 2026 23:22:07 +0100
Subject: [PATCH 04/11] Fix: expected result in write-reference test.
---
clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp b/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp
index 15387b10aad50..0ec58a7602b11 100644
--- a/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp
+++ b/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp
@@ -726,8 +726,8 @@ TEST(CallHierarchy, HierarchyOnVarWithWriteReference) {
EXPECT_THAT(
IncomingLevel1,
ElementsAre(AllOf(from(
- AllOf(withName("caller"),
- withReferenceTags(ReferenceTag::Write, ReferenceTag::Read))))));
+ AllOf(withName("caller"), withReferenceTags(ReferenceTag::Write))))));
+}
}
TEST(CallHierarchy, HierarchyOnVarWithUnaryReadWriteReference) {
>From e30941813a45fe04f0550dde1139184791ad8208 Mon Sep 17 00:00:00 2001
From: Dimitri Ratz <dimitri.ratz at thinkdigital.cc>
Date: Mon, 2 Feb 2026 23:24:48 +0100
Subject: [PATCH 05/11] New test: caller within a class.
---
.../clangd/unittests/CallHierarchyTests.cpp | 24 +++++++++++++++++++
1 file changed, 24 insertions(+)
diff --git a/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp b/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp
index 0ec58a7602b11..5582997148b33 100644
--- a/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp
+++ b/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp
@@ -728,6 +728,30 @@ TEST(CallHierarchy, HierarchyOnVarWithWriteReference) {
ElementsAre(AllOf(from(
AllOf(withName("caller"), withReferenceTags(ReferenceTag::Write))))));
}
+
+TEST(CallHierarchy, HierarchyOnClassMemberWithWriteReference) {
+ Annotations Source(R"cpp(
+ int v^ar = 1;
+ class MyClass {
+ public:
+ void caller() {
+ var = 2;
+ }
+ };
+ )cpp");
+ TestTU TU = TestTU::withCode(Source.code());
+ auto AST = TU.build();
+ auto Index = TU.index();
+
+ std::vector<CallHierarchyItem> Items =
+ prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
+ ASSERT_THAT(Items, ElementsAre(withName("var")));
+ auto IncomingLevel1 = incomingCalls(Items[0], Index.get(), AST);
+ ASSERT_FALSE(IncomingLevel1.empty());
+ EXPECT_THAT(
+ IncomingLevel1,
+ ElementsAre(AllOf(from(
+ AllOf(withName("caller"), withReferenceTags(ReferenceTag::Write))))));
}
TEST(CallHierarchy, HierarchyOnVarWithUnaryReadWriteReference) {
>From b41a24ecc1aebd0d2f63c97a7d022c8bfd775c2f Mon Sep 17 00:00:00 2001
From: Dimitri Ratz <dimitri.ratz at thinkdigital.cc>
Date: Mon, 2 Feb 2026 23:27:46 +0100
Subject: [PATCH 06/11] Replaced Visitor methods for unary and binary
operations with Traverse. Try to get the function definition before calling
analyseParameterUsage. Visit member expressions.
---
clang-tools-extra/clangd/XRefs.cpp | 74 ++++++++++++++++++++----------
1 file changed, 49 insertions(+), 25 deletions(-)
diff --git a/clang-tools-extra/clangd/XRefs.cpp b/clang-tools-extra/clangd/XRefs.cpp
index 69947c77238f6..668eade7eb084 100644
--- a/clang-tools-extra/clangd/XRefs.cpp
+++ b/clang-tools-extra/clangd/XRefs.cpp
@@ -1755,45 +1755,64 @@ class ParamUsageVisitor : public RecursiveASTVisitor<ParamUsageVisitor> {
bool HasWrite = false;
bool HasRead = false;
const ValueDecl *TargetParam;
+ llvm::SmallSet<const Expr *, 4> WriteOnlyExprs;
ParamUsageVisitor(const ValueDecl *P) : TargetParam(P) {}
- // Any reference to the target is at least a read, unless we later
- // identify it specifically as a write (e.g. assignment/inc/dec on LHS).
- bool VisitDeclRefExpr(DeclRefExpr *DRE) {
- if (DRE->getDecl() == TargetParam)
- HasRead = true;
- return true;
- }
-
- bool VisitUnaryOperator(UnaryOperator *UO) {
- // Check for increment/decrement on parameter
- if (UO->isIncrementDecrementOp()) {
- if (auto *DRE = dyn_cast<DeclRefExpr>(UO->getSubExpr())) {
+ // Identify write-only contexts before visiting children
+ bool TraverseBinaryOperator(BinaryOperator *BO) {
+ if (BO->isAssignmentOp()) {
+ auto *LHS = BO->getLHS()->IgnoreParenImpCasts();
+ if (auto *DRE = dyn_cast<DeclRefExpr>(LHS)) {
if (DRE->getDecl() == TargetParam) {
HasWrite = true;
+ // For pure assignment (=), LHS is write-only
+ if (BO->getOpcode() == BO_Assign)
+ WriteOnlyExprs.insert(DRE);
+ }
+ } else if (auto *ME = dyn_cast<MemberExpr>(LHS)) {
+ if (ME->getMemberDecl() == TargetParam) {
+ HasWrite = true;
+ if (BO->getOpcode() == BO_Assign)
+ WriteOnlyExprs.insert(ME);
}
}
}
- return true;
+ // Continue with default traversal
+ return RecursiveASTVisitor::TraverseBinaryOperator(BO);
}
- bool VisitBinaryOperator(BinaryOperator *BO) {
- // Check for assignment to parameter
- if (BO->isAssignmentOp()) {
- if (isa<DeclRefExpr>(BO->getLHS())) {
- auto *DRE = dyn_cast<DeclRefExpr>(BO->getLHS());
+
+ bool TraverseUnaryOperator(UnaryOperator *UO) {
+ if (UO->isIncrementDecrementOp()) {
+ auto *SubExpr = UO->getSubExpr()->IgnoreParenImpCasts();
+ if (auto *DRE = dyn_cast<DeclRefExpr>(SubExpr)) {
if (DRE->getDecl() == TargetParam) {
HasWrite = true;
+ // Inc/Dec is both read and write, don't add to WriteOnlyExprs
+ }
+ } else if (auto *ME = dyn_cast<MemberExpr>(SubExpr)) {
+ if (ME->getMemberDecl() == TargetParam) {
+ HasWrite = true;
}
}
}
+ return RecursiveASTVisitor::TraverseUnaryOperator(UO);
+ }
- // Any other use is at least a read
- if (isa<DeclRefExpr>(BO->getRHS())) {
- auto *DRE = dyn_cast<DeclRefExpr>(BO->getRHS());
- if (DRE->getDecl() == TargetParam) {
+ // Check for reads, excluding write-only contexts
+ bool VisitDeclRefExpr(DeclRefExpr *DRE) {
+ if (DRE->getDecl() == TargetParam) {
+ if (!WriteOnlyExprs.count(DRE))
+ HasRead = true;
+ }
+ return true;
+ }
+
+ // Handle member expressions
+ bool VisitMemberExpr(MemberExpr *ME) {
+ if (ME->getMemberDecl() == TargetParam) {
+ if (!WriteOnlyExprs.count(ME))
HasRead = true;
- }
}
return true;
}
@@ -2511,8 +2530,13 @@ incomingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index,
if (Decl.has_value() && Decl.value() != nullptr) {
if (const auto *VD =
llvm::dyn_cast<clang::ValueDecl>(Decl.value())) {
- CHI->referenceTags =
- analyseParameterUsage(FD, VD); // FD is the caller of var
+ // Use the function definition if available, not just a
+ // declaration
+ const FunctionDecl *FuncDef = FD->getDefinition();
+ if (!FuncDef)
+ FuncDef = FD;
+ CHI->referenceTags = analyseParameterUsage(
+ FuncDef, VD); // FuncDef is the caller of value decl VD
}
}
}
>From a6e99c5e0ae8ad2f731ee063dea6d2c070db181c Mon Sep 17 00:00:00 2001
From: Dimitri Ratz <dimitri.ratz at protonmail.com>
Date: Sun, 15 Feb 2026 22:26:47 +0100
Subject: [PATCH 07/11] New: traverse ctor declaration and corresponding unit
test.
---
clang-tools-extra/clangd/XRefs.cpp | 27 +++++++++----
.../clangd/unittests/CallHierarchyTests.cpp | 39 +++++++++++++++----
2 files changed, 51 insertions(+), 15 deletions(-)
diff --git a/clang-tools-extra/clangd/XRefs.cpp b/clang-tools-extra/clangd/XRefs.cpp
index 668eade7eb084..5f02eb9324e1e 100644
--- a/clang-tools-extra/clangd/XRefs.cpp
+++ b/clang-tools-extra/clangd/XRefs.cpp
@@ -1782,6 +1782,16 @@ class ParamUsageVisitor : public RecursiveASTVisitor<ParamUsageVisitor> {
return RecursiveASTVisitor::TraverseBinaryOperator(BO);
}
+ bool TraverseConstructorInitializer(CXXCtorInitializer *Init) {
+ if (Init) {
+ if (const FieldDecl *FD = Init->getMember()) {
+ if (FD == TargetParam)
+ HasWrite = true;
+ }
+ }
+ return RecursiveASTVisitor::TraverseConstructorInitializer(Init);
+ }
+
bool TraverseUnaryOperator(UnaryOperator *UO) {
if (UO->isIncrementDecrementOp()) {
auto *SubExpr = UO->getSubExpr()->IgnoreParenImpCasts();
@@ -1821,14 +1831,17 @@ class ParamUsageVisitor : public RecursiveASTVisitor<ParamUsageVisitor> {
static std::vector<ReferenceTag> analyseParameterUsage(const FunctionDecl *FD,
const ValueDecl *PVD) {
std::vector<ReferenceTag> Result;
- const Stmt *Body = FD->getBody();
- if (!Body)
- return Result; // No definition available
-
- // Walk the body and determine read/write usage of the referenced variable
- // within this function.
ParamUsageVisitor Visitor(PVD);
- Visitor.TraverseStmt(const_cast<Stmt *>(Body));
+
+ if (const auto *Ctor = dyn_cast<CXXConstructorDecl>(FD)) {
+ Visitor.TraverseDecl(const_cast<CXXConstructorDecl *>(Ctor));
+ } else if (const Stmt *Body = FD->getBody()) {
+ // Walk the body and determine read/write usage of the referenced variable
+ // within this function.
+ Visitor.TraverseStmt(const_cast<Stmt *>(Body));
+ } else
+ return Result;
+
if (Visitor.HasWrite)
Result.push_back(ReferenceTag::Write);
if (Visitor.HasRead)
diff --git a/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp b/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp
index 5582997148b33..72fb35c5ca027 100644
--- a/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp
+++ b/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp
@@ -731,14 +731,14 @@ TEST(CallHierarchy, HierarchyOnVarWithWriteReference) {
TEST(CallHierarchy, HierarchyOnClassMemberWithWriteReference) {
Annotations Source(R"cpp(
- int v^ar = 1;
- class MyClass {
- public:
- void caller() {
- var = 2;
- }
- };
- )cpp");
+ class MyClass {
+ public:
+ void caller() {
+ var = 2;
+ }
+ int v^ar = 1;
+ };
+ )cpp");
TestTU TU = TestTU::withCode(Source.code());
auto AST = TU.build();
auto Index = TU.index();
@@ -754,6 +754,29 @@ TEST(CallHierarchy, HierarchyOnClassMemberWithWriteReference) {
AllOf(withName("caller"), withReferenceTags(ReferenceTag::Write))))));
}
+TEST(CallHierarchy, HierarchyOnClassMemberWithWriteReferenceInCtorInitList) {
+ Annotations Source(R"cpp(
+ class MyClass {
+ int v^ar;
+ public:
+ MyClass() : var(1) {}
+ };
+ )cpp");
+ TestTU TU = TestTU::withCode(Source.code());
+ auto AST = TU.build();
+ auto Index = TU.index();
+
+ std::vector<CallHierarchyItem> Items =
+ prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
+ ASSERT_THAT(Items, ElementsAre(withName("var")));
+ auto IncomingLevel1 = incomingCalls(Items[0], Index.get(), AST);
+ ASSERT_FALSE(IncomingLevel1.empty());
+ EXPECT_THAT(
+ IncomingLevel1,
+ ElementsAre(AllOf(from(AllOf(withName("MyClass"),
+ withReferenceTags(ReferenceTag::Write))))));
+}
+
TEST(CallHierarchy, HierarchyOnVarWithUnaryReadWriteReference) {
Annotations Source(R"cpp(
int v^ar = 1;
>From c8d916f29e66bb1d4ccda8adf8150fcc6bc273ed Mon Sep 17 00:00:00 2001
From: Dimitri Ratz <dimitri.ratz at protonmail.com>
Date: Thu, 7 May 2026 11:03:53 +0200
Subject: [PATCH 08/11] [clangd] Refine incoming call hierarchy reference tags
Honor the client's referenceTags capability for callHierarchy/\nincomingCalls, recover target decls for header symbols when AST\nlookup falls back to the index, and treat compound assignments\nas both read and write accesses.
---
clang-tools-extra/clangd/ClangdLSPServer.cpp | 4 +-
clang-tools-extra/clangd/ClangdLSPServer.h | 2 +
clang-tools-extra/clangd/ClangdServer.cpp | 7 +-
clang-tools-extra/clangd/ClangdServer.h | 1 +
clang-tools-extra/clangd/Protocol.cpp | 9 +-
clang-tools-extra/clangd/Protocol.h | 17 +-
clang-tools-extra/clangd/XRefs.cpp | 199 +++++++++++++-----
clang-tools-extra/clangd/XRefs.h | 2 +-
.../clangd/unittests/CallHierarchyTests.cpp | 77 +++++++
.../clangd/unittests/ClangdLSPServerTests.cpp | 69 +++++-
10 files changed, 323 insertions(+), 64 deletions(-)
diff --git a/clang-tools-extra/clangd/ClangdLSPServer.cpp b/clang-tools-extra/clangd/ClangdLSPServer.cpp
index 0a57573ecc469..25603c9ed1ebe 100644
--- a/clang-tools-extra/clangd/ClangdLSPServer.cpp
+++ b/clang-tools-extra/clangd/ClangdLSPServer.cpp
@@ -537,6 +537,7 @@ void ClangdLSPServer::onInitialize(const InitializeParams &Params,
SupportsHierarchicalDocumentSymbol =
Params.capabilities.HierarchicalDocumentSymbol;
SupportsReferenceContainer = Params.capabilities.ReferenceContainer;
+ SupportsReferenceTags = Params.capabilities.ReferenceTagsSupport;
SupportFileStatus = Params.initializationOptions.FileStatus;
SupportsDocumentChanges = Params.capabilities.DocumentChanges;
SupportsChangeAnnotation = Params.capabilities.ChangeAnnotation;
@@ -1389,7 +1390,8 @@ void ClangdLSPServer::onPrepareCallHierarchy(
void ClangdLSPServer::onCallHierarchyIncomingCalls(
const CallHierarchyIncomingCallsParams &Params,
Callback<std::vector<CallHierarchyIncomingCall>> Reply) {
- Server->incomingCalls(Params.item.uri.file(), Params.item, std::move(Reply));
+ Server->incomingCalls(Params.item.uri.file(), Params.item,
+ SupportsReferenceTags, std::move(Reply));
}
void ClangdLSPServer::onClangdInlayHints(const InlayHintsParams &Params,
diff --git a/clang-tools-extra/clangd/ClangdLSPServer.h b/clang-tools-extra/clangd/ClangdLSPServer.h
index 6ada3fd9e6e47..860632476cbe4 100644
--- a/clang-tools-extra/clangd/ClangdLSPServer.h
+++ b/clang-tools-extra/clangd/ClangdLSPServer.h
@@ -299,6 +299,8 @@ class ClangdLSPServer : private ClangdServer::Callbacks,
bool SupportFileStatus = false;
/// Whether the client supports attaching a container string to references.
bool SupportsReferenceContainer = false;
+ /// Whether the client supports reference tags on hierarchy/reference items.
+ bool SupportsReferenceTags = false;
/// Which kind of markup should we use in textDocument/hover responses.
MarkupKind HoverContentFormat = MarkupKind::PlainText;
/// Whether the client supports offsets for parameter info labels.
diff --git a/clang-tools-extra/clangd/ClangdServer.cpp b/clang-tools-extra/clangd/ClangdServer.cpp
index dc81fe3df2794..267e05b71fc8d 100644
--- a/clang-tools-extra/clangd/ClangdServer.cpp
+++ b/clang-tools-extra/clangd/ClangdServer.cpp
@@ -912,13 +912,14 @@ void ClangdServer::prepareCallHierarchy(
}
void ClangdServer::incomingCalls(
- PathRef File, const CallHierarchyItem &Item,
+ PathRef File, const CallHierarchyItem &Item, bool ComputeReferenceTags,
Callback<std::vector<CallHierarchyIncomingCall>> CB) {
- auto Action = [Item, CB = std::move(CB),
+ auto Action = [Item, ComputeReferenceTags, CB = std::move(CB),
this](llvm::Expected<InputsAndAST> InpAST) mutable {
if (!InpAST)
return CB(InpAST.takeError());
- CB(clangd::incomingCalls(Item, Index, InpAST->AST));
+ CB(clangd::incomingCalls(Item, Index, InpAST->AST,
+ ComputeReferenceTags));
};
WorkScheduler->runWithAST("Incoming Calls", File, std::move(Action));
}
diff --git a/clang-tools-extra/clangd/ClangdServer.h b/clang-tools-extra/clangd/ClangdServer.h
index 8fe2c017033e9..1989969331259 100644
--- a/clang-tools-extra/clangd/ClangdServer.h
+++ b/clang-tools-extra/clangd/ClangdServer.h
@@ -303,6 +303,7 @@ class ClangdServer {
/// Resolve incoming calls for a given call hierarchy item.
void incomingCalls(PathRef File, const CallHierarchyItem &Item,
+ bool ComputeReferenceTags,
Callback<std::vector<CallHierarchyIncomingCall>>);
/// Resolve outgoing calls for a given call hierarchy item.
diff --git a/clang-tools-extra/clangd/Protocol.cpp b/clang-tools-extra/clangd/Protocol.cpp
index 6e0336122af23..60dddfcea62d8 100644
--- a/clang-tools-extra/clangd/Protocol.cpp
+++ b/clang-tools-extra/clangd/Protocol.cpp
@@ -398,9 +398,16 @@ bool fromJSON(const llvm::json::Value &Params, ClientCapabilities &R,
if (auto RelatedInfo = Diagnostics->getBoolean("relatedInformation"))
R.DiagnosticRelatedInformation = *RelatedInfo;
}
- if (auto *References = TextDocument->getObject("references"))
+ if (auto *References = TextDocument->getObject("references")) {
if (auto ContainerSupport = References->getBoolean("container"))
R.ReferenceContainer = *ContainerSupport;
+ if (auto ItemsSupport = References->getBoolean("referenceItemsSupport"))
+ R.ReferenceItemsSupport = *ItemsSupport;
+ }
+ if (auto *CallHierarchy = TextDocument->getObject("callHierarchy")) {
+ if (auto TagsSupport = CallHierarchy->getBoolean("referenceTagsSupport"))
+ R.ReferenceTagsSupport = *TagsSupport;
+ }
if (auto *Completion = TextDocument->getObject("completion")) {
if (auto *Item = Completion->getObject("completionItem")) {
if (auto SnippetSupport = Item->getBoolean("snippetSupport"))
diff --git a/clang-tools-extra/clangd/Protocol.h b/clang-tools-extra/clangd/Protocol.h
index d86ffe360f995..56738e3e93d57 100644
--- a/clang-tools-extra/clangd/Protocol.h
+++ b/clang-tools-extra/clangd/Protocol.h
@@ -575,6 +575,21 @@ struct ClientCapabilities {
/// notification. This is a clangd extension.
/// textDocument.inactiveRegionsCapabilities.inactiveRegions
bool InactiveRegions = false;
+
+ /// Determines whether the client supports reference tags on call hierarchy
+ /// items. If the value is missing, the server assumes that the client does
+ /// not support reference tags.
+ /// textDocument.callHierarchy.referenceTagsSupport
+ /// @since 3.18.0
+ bool ReferenceTagsSupport = false;
+
+ /// Determines whether the client supports and prefers Reference items instead
+ /// of Location items. If this value is missing, the server assumes that the
+ /// client accepts Location items as defined in earlier versions of the
+ /// protocol.
+ /// textDocument.references.referenceItemsSupport
+ /// @since 3.18.0
+ bool ReferenceItemsSupport = false;
};
bool fromJSON(const llvm::json::Value &, ClientCapabilities &,
llvm::json::Path);
@@ -1555,8 +1570,6 @@ struct TypeHierarchyItem {
/// The kind of this item.
SymbolKind kind;
- /// The symbol tags for this item.
- std::vector<ReferenceTag> referenceTags;
/// More detail for this item, e.g. the signature of a function.
std::optional<std::string> detail;
diff --git a/clang-tools-extra/clangd/XRefs.cpp b/clang-tools-extra/clangd/XRefs.cpp
index eac2d26593831..2cbcd89286dc8 100644
--- a/clang-tools-extra/clangd/XRefs.cpp
+++ b/clang-tools-extra/clangd/XRefs.cpp
@@ -1788,43 +1788,79 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
return OS;
}
-// This would require a visitor pattern:
+// Visitor to determine read/write access patterns of a target declaration
+// within a function body.
class ParamUsageVisitor : public RecursiveASTVisitor<ParamUsageVisitor> {
public:
bool HasWrite = false;
bool HasRead = false;
const ValueDecl *TargetParam;
+ std::optional<SymbolID> TargetID;
llvm::SmallSet<const Expr *, 4> WriteOnlyExprs;
- ParamUsageVisitor(const ValueDecl *P) : TargetParam(P) {}
+ ParamUsageVisitor(const ValueDecl *P)
+ : TargetParam(P ? llvm::dyn_cast<ValueDecl>(P->getCanonicalDecl())
+ : nullptr),
+ TargetID(P ? getSymbolID(P) : std::optional<SymbolID>{}) {}
- // Identify write-only contexts before visiting children
- bool TraverseBinaryOperator(BinaryOperator *BO) {
- if (BO->isAssignmentOp()) {
- auto *LHS = BO->getLHS()->IgnoreParenImpCasts();
- if (auto *DRE = dyn_cast<DeclRefExpr>(LHS)) {
- if (DRE->getDecl() == TargetParam) {
- HasWrite = true;
- // For pure assignment (=), LHS is write-only
- if (BO->getOpcode() == BO_Assign)
- WriteOnlyExprs.insert(DRE);
- }
- } else if (auto *ME = dyn_cast<MemberExpr>(LHS)) {
- if (ME->getMemberDecl() == TargetParam) {
- HasWrite = true;
- if (BO->getOpcode() == BO_Assign)
- WriteOnlyExprs.insert(ME);
- }
+ bool isTarget(const ValueDecl *VD) const {
+ if (!VD)
+ return false;
+
+ if (TargetParam) {
+ if (const auto *Canonical =
+ llvm::dyn_cast<ValueDecl>(VD->getCanonicalDecl()))
+ if (Canonical == TargetParam)
+ return true;
+ }
+
+ if (TargetID) {
+ if (auto ID = getSymbolID(VD))
+ return ID == *TargetID;
+ }
+
+ return false;
+ }
+
+ void markAssignmentLHS(const Expr *LHS, BinaryOperatorKind Opcode) {
+ const Expr *Base = LHS ? LHS->IgnoreParenImpCasts() : nullptr;
+ if (!Base)
+ return;
+
+ if (const auto *DRE = dyn_cast<DeclRefExpr>(Base)) {
+ if (isTarget(DRE->getDecl())) {
+ HasWrite = true;
+ // For pure assignment (=), LHS is write-only. Compound assignments
+ // such as += still read the previous value.
+ if (Opcode == BO_Assign)
+ WriteOnlyExprs.insert(DRE);
+ }
+ } else if (const auto *ME = dyn_cast<MemberExpr>(Base)) {
+ if (isTarget(ME->getMemberDecl())) {
+ HasWrite = true;
+ if (Opcode == BO_Assign)
+ WriteOnlyExprs.insert(ME);
}
}
+ }
+
+ // Identify write-only contexts before visiting children
+ bool TraverseBinaryOperator(BinaryOperator *BO) {
+ if (BO->isAssignmentOp())
+ markAssignmentLHS(BO->getLHS(), BO->getOpcode());
// Continue with default traversal
return RecursiveASTVisitor::TraverseBinaryOperator(BO);
}
+ bool TraverseCompoundAssignOperator(CompoundAssignOperator *CAO) {
+ markAssignmentLHS(CAO->getLHS(), CAO->getOpcode());
+ return RecursiveASTVisitor::TraverseCompoundAssignOperator(CAO);
+ }
+
bool TraverseConstructorInitializer(CXXCtorInitializer *Init) {
if (Init) {
if (const FieldDecl *FD = Init->getMember()) {
- if (FD == TargetParam)
+ if (isTarget(FD))
HasWrite = true;
}
}
@@ -1835,12 +1871,12 @@ class ParamUsageVisitor : public RecursiveASTVisitor<ParamUsageVisitor> {
if (UO->isIncrementDecrementOp()) {
auto *SubExpr = UO->getSubExpr()->IgnoreParenImpCasts();
if (auto *DRE = dyn_cast<DeclRefExpr>(SubExpr)) {
- if (DRE->getDecl() == TargetParam) {
+ if (isTarget(DRE->getDecl())) {
HasWrite = true;
// Inc/Dec is both read and write, don't add to WriteOnlyExprs
}
} else if (auto *ME = dyn_cast<MemberExpr>(SubExpr)) {
- if (ME->getMemberDecl() == TargetParam) {
+ if (isTarget(ME->getMemberDecl())) {
HasWrite = true;
}
}
@@ -1850,7 +1886,7 @@ class ParamUsageVisitor : public RecursiveASTVisitor<ParamUsageVisitor> {
// Check for reads, excluding write-only contexts
bool VisitDeclRefExpr(DeclRefExpr *DRE) {
- if (DRE->getDecl() == TargetParam) {
+ if (isTarget(DRE->getDecl())) {
if (!WriteOnlyExprs.count(DRE))
HasRead = true;
}
@@ -1859,7 +1895,7 @@ class ParamUsageVisitor : public RecursiveASTVisitor<ParamUsageVisitor> {
// Handle member expressions
bool VisitMemberExpr(MemberExpr *ME) {
- if (ME->getMemberDecl() == TargetParam) {
+ if (isTarget(ME->getMemberDecl())) {
if (!WriteOnlyExprs.count(ME))
HasRead = true;
}
@@ -2480,39 +2516,66 @@ prepareCallHierarchy(ParsedAST &AST, Position Pos, PathRef TUPath) {
return Result;
}
+// Walks the entire translation unit and returns the first NamedDecl whose
+// computed SymbolID matches the given ID. This allows finding declarations in
+// both the main file and included header files.
+static const NamedDecl *findDeclBySymbolID(const SymbolID &ID,
+ const ASTContext &Ctx) {
+ struct Finder : public RecursiveASTVisitor<Finder> {
+ const SymbolID &TargetID;
+ const NamedDecl *Result = nullptr;
+
+ Finder(const SymbolID &ID) : TargetID(ID) {}
+
+ bool VisitNamedDecl(NamedDecl *ND) {
+ if (Result)
+ return false; // Already found – stop early.
+ if (auto DeclID = getSymbolID(ND)) {
+ if (DeclID == TargetID) {
+ Result = ND;
+ return false;
+ }
+ }
+ return true;
+ }
+ };
+
+ Finder F(ID);
+ F.TraverseDecl(Ctx.getTranslationUnitDecl());
+ return F.Result;
+}
+
// Tries to find a NamedDecl in the AST that matches the given Symbol.
+// First attempts a fast path via source location (main file). If that fails
+// (e.g. the symbol lives in an included header), falls back to a SymbolID-
+// based walk of the full translation unit.
// Returns nullptr if the symbol is not found in the current AST.
-const NamedDecl *getNamedDeclFromSymbol(const Symbol &Sym,
- const ParsedAST &AST) {
- // Try to convert the symbol to a location and find the decl at that location
+static const NamedDecl *getNamedDeclFromSymbol(const Symbol &Sym,
+ const ParsedAST &AST) {
+ // Fast path: symbol is in the main file – use source-location lookup.
auto SymLoc = symbolToLocation(Sym, AST.tuPath());
- if (!SymLoc)
- return nullptr;
-
- // Check if the symbol location is in the main file
- if (SymLoc->uri.file() != AST.tuPath())
- return nullptr;
-
- // Convert LSP position to source location
- const auto &SM = AST.getSourceManager();
- auto CurLoc = sourceLocationInMainFile(SM, SymLoc->range.start);
- if (!CurLoc) {
- llvm::consumeError(CurLoc.takeError());
- return nullptr;
+ if (SymLoc && SymLoc->uri.file() == AST.tuPath()) {
+ const auto &SM = AST.getSourceManager();
+ auto CurLoc = sourceLocationInMainFile(SM, SymLoc->range.start);
+ if (CurLoc) {
+ auto Decls =
+ getDeclAtPosition(const_cast<ParsedAST &>(AST), *CurLoc, {});
+ if (!Decls.empty())
+ return Decls[0];
+ } else {
+ llvm::consumeError(CurLoc.takeError());
+ }
}
- // Get all decls at this location
- auto Decls = getDeclAtPosition(const_cast<ParsedAST &>(AST), *CurLoc, {});
- if (Decls.empty())
- return nullptr;
-
- // Return the first decl (usually the most specific one)
- return Decls[0];
+ // Slow path: symbol is in an included header – walk the entire TU by
+ // SymbolID. This is needed so that analyseParameterUsage can still receive
+ // a valid ValueDecl* for the target symbol.
+ return findDeclBySymbolID(Sym.ID, AST.getASTContext());
}
std::vector<CallHierarchyIncomingCall>
incomingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index,
- ParsedAST &AST) {
+ ParsedAST &AST, bool ComputeReferenceTags) {
std::vector<CallHierarchyIncomingCall> Results;
if (!Index || Item.data.empty())
return Results;
@@ -2581,17 +2644,45 @@ incomingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index,
std::optional<CallHierarchyItem> CHI;
if (auto *ND = getNamedDeclFromSymbol(Caller, AST)) {
CHI = declToCallHierarchyItem(*ND, AST.tuPath());
- if (const auto *FD = llvm::dyn_cast<clang::FunctionDecl>(ND)) {
- if (Decl.has_value() && Decl.value() != nullptr) {
- if (const auto *VD =
- llvm::dyn_cast<clang::ValueDecl>(Decl.value())) {
+ if (ComputeReferenceTags) {
+ if (const auto *FD = llvm::dyn_cast<clang::FunctionDecl>(ND)) {
+ const ValueDecl *VD = nullptr;
+ if (Decl.has_value() && Decl.value() != nullptr)
+ VD = llvm::dyn_cast<clang::ValueDecl>(Decl.value());
+
+ // Header symbols can come from preamble/external AST, where the
+ // declaration may not be discoverable through symbol lookup.
+ // Fall back to resolving the referenced decl at a call site.
+ if (!VD) {
+ const auto &SM = AST.getSourceManager();
+ for (const Location &L : It->second) {
+ if (L.uri.file() != AST.tuPath())
+ continue;
+ auto RefLoc = sourceLocationInMainFile(SM, L.range.start);
+ if (!RefLoc) {
+ llvm::consumeError(RefLoc.takeError());
+ continue;
+ }
+ for (const NamedDecl *AtPos : getDeclAtPosition(AST, *RefLoc, {})) {
+ if (const auto *Resolved =
+ llvm::dyn_cast<clang::ValueDecl>(AtPos)) {
+ VD = Resolved;
+ break;
+ }
+ }
+ if (VD)
+ break;
+ }
+ }
+
+ if (VD) {
// Use the function definition if available, not just a
- // declaration
+ // declaration.
const FunctionDecl *FuncDef = FD->getDefinition();
if (!FuncDef)
FuncDef = FD;
CHI->referenceTags = analyseParameterUsage(
- FuncDef, VD); // FuncDef is the caller of value decl VD
+ FuncDef, VD); // FuncDef is the caller of value decl VD.
}
}
}
diff --git a/clang-tools-extra/clangd/XRefs.h b/clang-tools-extra/clangd/XRefs.h
index 31e7b0b14440f..4dfc530b4fe9c 100644
--- a/clang-tools-extra/clangd/XRefs.h
+++ b/clang-tools-extra/clangd/XRefs.h
@@ -149,7 +149,7 @@ prepareCallHierarchy(ParsedAST &AST, Position Pos, PathRef TUPath);
std::vector<CallHierarchyIncomingCall>
incomingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index,
- ParsedAST &AST);
+ ParsedAST &AST, bool ComputeReferenceTags = true);
std::vector<CallHierarchyOutgoingCall>
outgoingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index);
diff --git a/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp b/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp
index 72fb35c5ca027..ff6be2ca875ad 100644
--- a/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp
+++ b/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp
@@ -729,6 +729,30 @@ TEST(CallHierarchy, HierarchyOnVarWithWriteReference) {
AllOf(withName("caller"), withReferenceTags(ReferenceTag::Write))))));
}
+TEST(CallHierarchy, HierarchyOnVarWithoutReferenceTagsSupport) {
+ Annotations Source(R"cpp(
+ int v^ar = 1;
+ void caller() {
+ var = 2;
+ }
+ )cpp");
+ TestTU TU = TestTU::withCode(Source.code());
+ auto AST = TU.build();
+ auto Index = TU.index();
+
+ std::vector<CallHierarchyItem> Items =
+ prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
+ ASSERT_THAT(Items, ElementsAre(withName("var")));
+
+ auto IncomingLevel1 = incomingCalls(Items[0], Index.get(), AST,
+ /*ComputeReferenceTags=*/false);
+ ASSERT_FALSE(IncomingLevel1.empty());
+ EXPECT_THAT(IncomingLevel1,
+ ElementsAre(AllOf(from(Field(&CallHierarchyItem::name, "caller")),
+ from(Field(&CallHierarchyItem::referenceTags,
+ IsEmpty())))));
+}
+
TEST(CallHierarchy, HierarchyOnClassMemberWithWriteReference) {
Annotations Source(R"cpp(
class MyClass {
@@ -800,6 +824,59 @@ TEST(CallHierarchy, HierarchyOnVarWithUnaryReadWriteReference) {
withReferenceTags(ReferenceTag::Write, ReferenceTag::Read))))));
}
+TEST(CallHierarchy, HierarchyOnVarWithCompoundAssignmentReference) {
+ // Compound assignment (e.g. +=) is both a read and a write.
+ Annotations Source(R"cpp(
+ int v^ar = 1;
+ void caller() {
+ var += 2;
+ }
+ )cpp");
+ TestTU TU = TestTU::withCode(Source.code());
+ auto AST = TU.build();
+ auto Index = TU.index();
+
+ std::vector<CallHierarchyItem> Items =
+ prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
+ ASSERT_THAT(Items, ElementsAre(withName("var")));
+ auto IncomingLevel1 = incomingCalls(Items[0], Index.get(), AST);
+ ASSERT_FALSE(IncomingLevel1.empty());
+ EXPECT_THAT(
+ IncomingLevel1,
+ UnorderedElementsAre(AllOf(from(AllOf(
+ withName("caller"),
+ withReferenceTags(ReferenceTag::Write, ReferenceTag::Read))))));
+}
+
+TEST(CallHierarchy, HierarchyOnHeaderVarWithWriteReference) {
+ // Verifies that reference tags are computed even when the target symbol lives
+ // in a header file (not the main translation unit).
+ Annotations Header(R"cpp(
+ int var = 1;
+ )cpp");
+ Annotations Source(R"cpp(
+ #include "HeaderSymbol.h"
+ void caller() {
+ v^ar = 2;
+ }
+ )cpp");
+ TestTU TU = TestTU::withCode(Source.code());
+ TU.HeaderFilename = "HeaderSymbol.h";
+ TU.HeaderCode = Header.code();
+ auto AST = TU.build();
+ auto Index = TU.index();
+
+ std::vector<CallHierarchyItem> Items =
+ prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
+ ASSERT_THAT(Items, ElementsAre(withName("var")));
+ auto IncomingLevel1 = incomingCalls(Items[0], Index.get(), AST);
+ ASSERT_FALSE(IncomingLevel1.empty());
+ EXPECT_THAT(IncomingLevel1,
+ ElementsAre(AllOf(from(AllOf(
+ withName("caller"),
+ withReferenceTags(ReferenceTag::Write))))));
+}
+
TEST(CallHierarchy, HierarchyOnEnumConstant) {
// Tests that the call hierarchy works on enum constants.
Annotations Source(R"cpp(
diff --git a/clang-tools-extra/clangd/unittests/ClangdLSPServerTests.cpp b/clang-tools-extra/clangd/unittests/ClangdLSPServerTests.cpp
index 95bf5e54fc792..bd5e07f24dcbc 100644
--- a/clang-tools-extra/clangd/unittests/ClangdLSPServerTests.cpp
+++ b/clang-tools-extra/clangd/unittests/ClangdLSPServerTests.cpp
@@ -65,11 +65,11 @@ class LSPTest : public ::testing::Test {
Base.FeatureModules = &FeatureModules;
}
- LSPClient &start() {
+ LSPClient &start(llvm::json::Object InitializeParams = {}) {
EXPECT_FALSE(Server) << "Already initialized";
Server.emplace(Client.transport(), FS, Opts);
ServerThread.emplace([&] { EXPECT_TRUE(Server->run()); });
- Client.call("initialize", llvm::json::Object{});
+ Client.call("initialize", std::move(InitializeParams));
return Client;
}
@@ -307,6 +307,71 @@ TEST_F(LSPTest, IncomingCalls) {
EXPECT_EQ(From["name"], "caller1");
}
+TEST_F(LSPTest, IncomingCallsWithReferenceTagsSupport) {
+ Annotations Code(R"cpp(
+ int va^r = 1;
+ void caller() {
+ var = 2;
+ }
+ )cpp");
+ auto &Client = start(llvm::json::Object{{
+ "capabilities",
+ llvm::json::Object{{
+ "textDocument",
+ llvm::json::Object{{
+ "callHierarchy",
+ llvm::json::Object{{"referenceTagsSupport", true}},
+ }},
+ }},
+ }});
+ Client.didOpen("foo.cpp", Code.code());
+ auto Items = Client
+ .call("textDocument/prepareCallHierarchy",
+ llvm::json::Object{{
+ "textDocument", Client.documentID("foo.cpp")},
+ {"position", Code.point()}})
+ .takeValue();
+ auto FirstItem = (*Items.getAsArray())[0];
+ auto Calls = Client
+ .call("callHierarchy/incomingCalls",
+ llvm::json::Object{{"item", FirstItem}})
+ .takeValue();
+ auto FirstCall = *(*Calls.getAsArray())[0].getAsObject();
+ auto From = *FirstCall["from"].getAsObject();
+
+ EXPECT_EQ(From["name"], "caller");
+ EXPECT_EQ(From["referenceTags"],
+ llvm::json::Value(llvm::json::Array{static_cast<int>(
+ ReferenceTag::Write)}));
+}
+
+TEST_F(LSPTest, IncomingCallsWithoutReferenceTagsSupport) {
+ Annotations Code(R"cpp(
+ int va^r = 1;
+ void caller() {
+ var = 2;
+ }
+ )cpp");
+ auto &Client = start();
+ Client.didOpen("foo.cpp", Code.code());
+ auto Items = Client
+ .call("textDocument/prepareCallHierarchy",
+ llvm::json::Object{{
+ "textDocument", Client.documentID("foo.cpp")},
+ {"position", Code.point()}})
+ .takeValue();
+ auto FirstItem = (*Items.getAsArray())[0];
+ auto Calls = Client
+ .call("callHierarchy/incomingCalls",
+ llvm::json::Object{{"item", FirstItem}})
+ .takeValue();
+ auto FirstCall = *(*Calls.getAsArray())[0].getAsObject();
+ auto From = *FirstCall["from"].getAsObject();
+
+ EXPECT_EQ(From["name"], "caller");
+ EXPECT_FALSE(From.get("referenceTags"));
+}
+
TEST_F(LSPTest, CDBConfigIntegration) {
auto CfgProvider =
config::Provider::fromAncestorRelativeYAMLFiles(".clangd", FS);
>From aa42b7204d65a861c06249941bc85d3e0ba38137 Mon Sep 17 00:00:00 2001
From: Dimitri Ratz <dimitri.ratz at protonmail.com>
Date: Wed, 13 May 2026 17:52:47 +0200
Subject: [PATCH 09/11] [clangd] Add read/write reference tags to outgoing
variable hierarchy items
Extend call hierarchy outgoing results to annotate variable/field references
with read/write `referenceTags` when supported by the client.
- keep function calls untagged (no [clangd] Add outgoing call reference tags with fast-path and stable ordering
Compute read/write reference tags for outgoing call hierarchy entries on
variables and fields, while keeping function calls untagged.
- preserve index-only outgoing call resolution when reference tags are not needed
- keep outgoing results deterministically ordered
- compute variable/field usage in a single AST traversal
- add and update unit/LSP tests for tagged outgoing calls read/write classification)
- preserve existing incomingCalls behavior (no functional changes)
- update/adjust outgoing-focused tests to cover variable/field tagging
---
clang-tools-extra/clangd/ClangdLSPServer.cpp | 3 +-
clang-tools-extra/clangd/ClangdServer.cpp | 25 +-
clang-tools-extra/clangd/ClangdServer.h | 3 +-
clang-tools-extra/clangd/XRefs.cpp | 297 ++++++++++++--
clang-tools-extra/clangd/XRefs.h | 7 +-
clang-tools-extra/clangd/index/Ref.h | 4 +-
.../clangd/unittests/CallHierarchyTests.cpp | 369 +++++++++++++++++-
.../clangd/unittests/ClangdLSPServerTests.cpp | 58 ++-
8 files changed, 715 insertions(+), 51 deletions(-)
diff --git a/clang-tools-extra/clangd/ClangdLSPServer.cpp b/clang-tools-extra/clangd/ClangdLSPServer.cpp
index 25603c9ed1ebe..289fda9c00550 100644
--- a/clang-tools-extra/clangd/ClangdLSPServer.cpp
+++ b/clang-tools-extra/clangd/ClangdLSPServer.cpp
@@ -1436,7 +1436,8 @@ void ClangdLSPServer::onInlayHint(const InlayHintsParams &Params,
void ClangdLSPServer::onCallHierarchyOutgoingCalls(
const CallHierarchyOutgoingCallsParams &Params,
Callback<std::vector<CallHierarchyOutgoingCall>> Reply) {
- Server->outgoingCalls(Params.item, std::move(Reply));
+ Server->outgoingCalls(Params.item.uri.file(), Params.item,
+ SupportsReferenceTags, std::move(Reply));
}
void ClangdLSPServer::applyConfiguration(
diff --git a/clang-tools-extra/clangd/ClangdServer.cpp b/clang-tools-extra/clangd/ClangdServer.cpp
index 267e05b71fc8d..a14891008799f 100644
--- a/clang-tools-extra/clangd/ClangdServer.cpp
+++ b/clang-tools-extra/clangd/ClangdServer.cpp
@@ -936,12 +936,27 @@ void ClangdServer::inlayHints(PathRef File, std::optional<Range> RestrictRange,
}
void ClangdServer::outgoingCalls(
- const CallHierarchyItem &Item,
+ PathRef File, const CallHierarchyItem &Item, bool ComputeReferenceTags,
Callback<std::vector<CallHierarchyOutgoingCall>> CB) {
- WorkScheduler->run("Outgoing Calls", "",
- [CB = std::move(CB), Item, this]() mutable {
- CB(clangd::outgoingCalls(Item, Index));
- });
+ if (!ComputeReferenceTags) {
+ // Fast path: reference tags are not requested, so no AST is needed.
+ // Dispatch as an index-only task to avoid unnecessary parse latency.
+ WorkScheduler->run("Outgoing Calls", "",
+ [Item, CB = std::move(CB), this]() mutable {
+ CB(clangd::outgoingCalls(Item, Index,
+ /*AST=*/nullptr,
+ /*ComputeReferenceTags=*/false));
+ });
+ return;
+ }
+ auto Action = [Item, CB = std::move(CB),
+ this](llvm::Expected<InputsAndAST> InpAST) mutable {
+ if (!InpAST)
+ return CB(InpAST.takeError());
+ CB(clangd::outgoingCalls(Item, Index, &InpAST->AST,
+ /*ComputeReferenceTags=*/true));
+ };
+ WorkScheduler->runWithAST("Outgoing Calls", File, std::move(Action));
}
void ClangdServer::onFileEvent(const DidChangeWatchedFilesParams &Params) {
diff --git a/clang-tools-extra/clangd/ClangdServer.h b/clang-tools-extra/clangd/ClangdServer.h
index 1989969331259..fe88281a967f9 100644
--- a/clang-tools-extra/clangd/ClangdServer.h
+++ b/clang-tools-extra/clangd/ClangdServer.h
@@ -307,7 +307,8 @@ class ClangdServer {
Callback<std::vector<CallHierarchyIncomingCall>>);
/// Resolve outgoing calls for a given call hierarchy item.
- void outgoingCalls(const CallHierarchyItem &Item,
+ void outgoingCalls(PathRef File, const CallHierarchyItem &Item,
+ bool ComputeReferenceTags,
Callback<std::vector<CallHierarchyOutgoingCall>>);
/// Resolve inlay hints for a given document.
diff --git a/clang-tools-extra/clangd/XRefs.cpp b/clang-tools-extra/clangd/XRefs.cpp
index 2cbcd89286dc8..b80990eaa789f 100644
--- a/clang-tools-extra/clangd/XRefs.cpp
+++ b/clang-tools-extra/clangd/XRefs.cpp
@@ -1925,6 +1925,136 @@ static std::vector<ReferenceTag> analyseParameterUsage(const FunctionDecl *FD,
return Result;
}
+/// Visitor that determines read/write access patterns for a set of variables
+/// in a single traversal of a function body. This avoids the O(N * body_size)
+/// cost of calling analyseParameterUsage once per variable.
+class BulkVarUsageVisitor
+ : public RecursiveASTVisitor<BulkVarUsageVisitor> {
+public:
+ /// Per-symbol result: (hasRead, hasWrite).
+ llvm::DenseMap<SymbolID, std::pair<bool, bool>> Usage;
+
+ BulkVarUsageVisitor(llvm::ArrayRef<std::pair<SymbolID, const ValueDecl *>>
+ Targets) {
+ for (const auto &[ID, VD] : Targets)
+ Usage.try_emplace(ID, false, false);
+ }
+
+ // Identifies write-only LHS expressions before visiting children.
+ bool TraverseBinaryOperator(BinaryOperator *BO) {
+ if (BO->isAssignmentOp())
+ markLHSWrite(BO->getLHS(), BO->getOpcode());
+ return RecursiveASTVisitor::TraverseBinaryOperator(BO);
+ }
+
+ bool TraverseCompoundAssignOperator(CompoundAssignOperator *CAO) {
+ markLHSWrite(CAO->getLHS(), CAO->getOpcode());
+ return RecursiveASTVisitor::TraverseCompoundAssignOperator(CAO);
+ }
+
+ bool TraverseConstructorInitializer(CXXCtorInitializer *Init) {
+ if (Init) {
+ if (const FieldDecl *FD = Init->getMember()) {
+ if (auto ID = getSymbolID(FD)) {
+ if (auto Entry = Usage.find(ID); Entry != Usage.end())
+ Entry->second.second = true; // hasWrite
+ }
+ }
+ }
+ return RecursiveASTVisitor::TraverseConstructorInitializer(Init);
+ }
+
+ bool TraverseUnaryOperator(UnaryOperator *UO) {
+ if (UO->isIncrementDecrementOp()) {
+ const Expr *Sub = UO->getSubExpr()->IgnoreParenImpCasts();
+ if (const ValueDecl *VD = getDeclFromExpr(Sub)) {
+ if (auto ID = getSymbolID(VD)) {
+ if (auto Entry = Usage.find(ID); Entry != Usage.end())
+ Entry->second.second = true; // hasWrite (also hasRead via Visit*)
+ }
+ }
+ }
+ return RecursiveASTVisitor::TraverseUnaryOperator(UO);
+ }
+
+ bool VisitDeclRefExpr(DeclRefExpr *DRE) {
+ if (auto ID = getSymbolID(DRE->getDecl())) {
+ if (auto Entry = Usage.find(ID); Entry != Usage.end()) {
+ if (!WriteOnlyExprs.count(DRE))
+ Entry->second.first = true; // hasRead
+ }
+ }
+ return true;
+ }
+
+ bool VisitMemberExpr(MemberExpr *ME) {
+ if (auto ID = getSymbolID(ME->getMemberDecl())) {
+ if (auto Entry = Usage.find(ID); Entry != Usage.end()) {
+ if (!WriteOnlyExprs.count(ME))
+ Entry->second.first = true; // hasRead
+ }
+ }
+ return true;
+ }
+
+private:
+ llvm::SmallDenseSet<const Expr *, 8> WriteOnlyExprs;
+
+ static const ValueDecl *getDeclFromExpr(const Expr *E) {
+ if (const auto *DRE = dyn_cast<DeclRefExpr>(E))
+ return DRE->getDecl();
+ if (const auto *ME = dyn_cast<MemberExpr>(E))
+ return ME->getMemberDecl();
+ return nullptr;
+ }
+
+ void markLHSWrite(const Expr *LHS, BinaryOperatorKind Opcode) {
+ const Expr *Base = LHS ? LHS->IgnoreParenImpCasts() : nullptr;
+ if (!Base)
+ return;
+ const ValueDecl *VD = getDeclFromExpr(Base);
+ if (!VD)
+ return;
+ if (auto ID = getSymbolID(VD)) {
+ if (auto Entry = Usage.find(ID); Entry != Usage.end()) {
+ Entry->second.second = true; // hasWrite
+ // Pure assignment: the LHS itself is write-only (no prior read).
+ if (Opcode == BO_Assign)
+ WriteOnlyExprs.insert(Base);
+ }
+ }
+ }
+};
+
+/// Analyses read/write usage of \p Decls within \p FD in a single traversal.
+/// Returns a map from SymbolID to the corresponding reference tags.
+static llvm::DenseMap<SymbolID, std::vector<ReferenceTag>>
+analyseAllVarUsages(const FunctionDecl *FD,
+ const llvm::DenseMap<SymbolID, const NamedDecl *> &Decls) {
+ llvm::SmallVector<std::pair<SymbolID, const ValueDecl *>> Targets;
+ for (const auto &[ID, ND] : Decls) {
+ if (const auto *VD = llvm::dyn_cast<ValueDecl>(ND))
+ Targets.emplace_back(ID, VD);
+ }
+
+ BulkVarUsageVisitor Visitor(Targets);
+ if (const auto *Ctor = dyn_cast<CXXConstructorDecl>(FD))
+ Visitor.TraverseDecl(const_cast<CXXConstructorDecl *>(Ctor));
+ else if (const Stmt *Body = FD->getBody())
+ Visitor.TraverseStmt(const_cast<Stmt *>(Body));
+
+ llvm::DenseMap<SymbolID, std::vector<ReferenceTag>> Result;
+ for (auto &[ID, RW] : Visitor.Usage) {
+ std::vector<ReferenceTag> Tags;
+ if (RW.second) // hasWrite
+ Tags.push_back(ReferenceTag::Write);
+ if (RW.first) // hasRead
+ Tags.push_back(ReferenceTag::Read);
+ Result.try_emplace(ID, std::move(Tags));
+ }
+ return Result;
+}
+
template <typename HierarchyItem>
static std::optional<HierarchyItem>
declToHierarchyItem(const NamedDecl &ND, llvm::StringRef TUPath) {
@@ -2727,7 +2857,8 @@ incomingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index,
}
std::vector<CallHierarchyOutgoingCall>
-outgoingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index) {
+outgoingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index,
+ ParsedAST *AST, bool ComputeReferenceTags) {
std::vector<CallHierarchyOutgoingCall> Results;
if (!Index || Item.data.empty())
return Results;
@@ -2736,15 +2867,48 @@ outgoingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index) {
elog("outgoingCalls failed to find symbol: {0}", ID.takeError());
return Results;
}
- // In this function, we find outgoing calls based on the index only.
+
+ // Resolve the caller's FunctionDecl from the AST so that variable/field
+ // reference tags can be computed. Only attempted when the client opted in
+ // via ComputeReferenceTags and an AST for the caller's file is available.
+ const FunctionDecl *CallerFunc = nullptr;
+ if (ComputeReferenceTags && AST) {
+ LookupRequest CallerLookup;
+ CallerLookup.IDs.insert(*ID);
+ Index->lookup(CallerLookup, [&](const Symbol &Caller) {
+ if (Caller.ID != *ID || CallerFunc)
+ return;
+ if (const auto *ND = getNamedDeclFromSymbol(Caller, *AST))
+ CallerFunc = llvm::dyn_cast<FunctionDecl>(ND);
+ });
+
+ // If index-based lookup did not resolve the declaration, fall back to the
+ // request item's selection range in the current AST.
+ if (!CallerFunc && Item.uri.file() == AST->tuPath()) {
+ auto CurLoc = sourceLocationInMainFile(AST->getSourceManager(),
+ Item.selectionRange.start);
+ if (CurLoc) {
+ for (const NamedDecl *AtPos : getDeclAtPosition(*AST, *CurLoc, {})) {
+ if (const auto *FD = llvm::dyn_cast<FunctionDecl>(AtPos)) {
+ CallerFunc = FD;
+ break;
+ }
+ }
+ } else {
+ llvm::consumeError(CurLoc.takeError());
+ }
+ }
+
+ if (CallerFunc) {
+ if (const auto *Def = CallerFunc->getDefinition())
+ CallerFunc = Def;
+ }
+ }
+
+ // Outgoing call edges for functions are collected from the index.
ContainedRefsRequest Request;
Request.ID = *ID;
- // 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.
llvm::DenseMap<SymbolID, std::vector<Location>> CallsOut;
- // We can populate the ranges based on a refs request only. As we do so, we
- // also accumulate the callee IDs into a lookup request.
LookupRequest CallsOutLookup;
Index->containedRefs(Request, [&](const auto &R) {
auto Loc = indexToLSPLocation(R.Location, Item.uri.file());
@@ -2754,47 +2918,122 @@ outgoingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index) {
}
auto It = CallsOut.try_emplace(R.Symbol, std::vector<Location>{}).first;
It->second.push_back(*Loc);
-
CallsOutLookup.IDs.insert(R.Symbol);
});
- // Perform the lookup request and combine its results with CallsOut to
- // get complete CallHierarchyOutgoingCall objects.
- Index->lookup(CallsOutLookup, [&](const Symbol &Callee) {
- // The containedRefs request should only return symbols which are
- // function-like, i.e. symbols for which references to them can be "calls".
- using SK = index::SymbolKind;
- auto Kind = Callee.SymInfo.Kind;
- assert(Kind == SK::Function || Kind == SK::InstanceMethod ||
- Kind == SK::ClassMethod || Kind == SK::StaticMethod ||
- Kind == SK::Constructor || Kind == SK::Destructor ||
- Kind == SK::ConversionFunction);
- (void)Kind;
- (void)SK::Function;
+ Index->lookup(CallsOutLookup, [&](const Symbol &Callee) {
auto It = CallsOut.find(Callee.ID);
assert(It != CallsOut.end());
if (auto CHI = symbolToCallHierarchyItem(Callee, Item.uri.file())) {
+ if (CHI->kind != SymbolKind::Function &&
+ CHI->kind != SymbolKind::Method &&
+ CHI->kind != SymbolKind::Constructor)
+ return;
std::vector<Range> FromRanges;
for (const Location &L : It->second) {
- if (L.uri != Item.uri) {
- // Call location not in same file as the item that outgoingCalls was
- // requested for. This can happen when Item is a declaration separate
- // from the implementation. There's not much we can do, since the
- // protocol only allows returning ranges interpreted as being in
- // Item's file.
+ if (L.uri != Item.uri)
continue;
- }
FromRanges.push_back(L.range);
}
Results.push_back(
CallHierarchyOutgoingCall{std::move(*CHI), std::move(FromRanges)});
}
});
- // Sort results by name of the callee.
+
+ // When the client supports reference tags, also include variable/field
+ // references from the current function body and classify them as
+ // reads/writes. Function callees are still modeled as plain outgoing calls
+ // and do not receive reference tags.
+ // A single bulk traversal (BulkVarUsageVisitor / analyseAllVarUsages) is
+ // used to avoid O(N * body_size) cost when many variables are referenced.
+ if (ComputeReferenceTags && AST && CallerFunc &&
+ Item.uri.file() == AST->tuPath()) {
+ llvm::DenseMap<SymbolID, std::vector<Range>> NonCallRefs;
+ llvm::DenseMap<SymbolID, const NamedDecl *> NonCallDecls;
+ using SK = index::SymbolKind;
+
+ findExplicitReferences(
+ CallerFunc,
+ [&](ReferenceLoc Ref) {
+ if (Ref.IsDecl)
+ return;
+ auto Loc = makeLocation(AST->getASTContext(), Ref.NameLoc,
+ Item.uri.file());
+ if (!Loc)
+ return;
+ for (const Decl *D : Ref.Targets) {
+ if (index::isFunctionLocalSymbol(D) || D->isTemplateParameter())
+ continue;
+ const auto *VD = llvm::dyn_cast<ValueDecl>(D);
+ if (!VD)
+ continue;
+ auto Kind = index::getSymbolInfo(D).Kind;
+ if (Kind != SK::Variable && Kind != SK::Field)
+ continue;
+ SymbolID DeclID = getSymbolID(D);
+ if (!DeclID)
+ continue;
+ NonCallDecls.try_emplace(DeclID, llvm::cast<NamedDecl>(D));
+ NonCallRefs[DeclID].push_back(Loc->range);
+ }
+ },
+ AST->getHeuristicResolver());
+
+ // Collect IDs already covered by index-based function call results so we
+ // don't emit a duplicate entry for a symbol that is both called and
+ // referenced as a variable.
+ llvm::DenseSet<SymbolID> ProcessedIDs;
+ for (const auto &Call : Results) {
+ if (!Call.to.data.empty()) {
+ if (auto SID = SymbolID::fromStr(Call.to.data))
+ ProcessedIDs.insert(*SID);
+ }
+ }
+
+ // Single-pass bulk analysis of all referenced variables/fields.
+ auto TagMap = analyseAllVarUsages(CallerFunc, NonCallDecls);
+
+ for (auto &Entry : NonCallRefs) {
+ const SymbolID &DeclID = Entry.first;
+ if (ProcessedIDs.count(DeclID))
+ continue;
+ const auto *ND = NonCallDecls.lookup(DeclID);
+ if (!ND)
+ continue;
+ auto CHI = declToCallHierarchyItem(*ND, Item.uri.file());
+ if (!CHI)
+ continue;
+ if (auto TagIt = TagMap.find(DeclID); TagIt != TagMap.end())
+ CHI->referenceTags = TagIt->second;
+ CHI->data = DeclID.str();
+ Results.push_back(
+ CallHierarchyOutgoingCall{std::move(*CHI), std::move(Entry.second)});
+ }
+ }
+
+ // Sort results by first source position so the order is deterministic and
+ // matches reading order. Entries without any fromRanges (e.g. cross-file
+ // callees) sort after all positioned entries, then alphabetically.
llvm::sort(Results, [](const CallHierarchyOutgoingCall &A,
const CallHierarchyOutgoingCall &B) {
+ auto FirstPos = [](const std::vector<Range> &Ranges) -> Position {
+ Position Best{INT_MAX, INT_MAX};
+ for (const auto &R : Ranges)
+ if (R.start.line < Best.line ||
+ (R.start.line == Best.line &&
+ R.start.character < Best.character))
+ Best = R.start;
+ return Best;
+ };
+ Position APos = FirstPos(A.fromRanges);
+ Position BPos = FirstPos(B.fromRanges);
+ if (APos.line != BPos.line)
+ return APos.line < BPos.line;
+ if (APos.character != BPos.character)
+ return APos.character < BPos.character;
return A.to.name < B.to.name;
});
+
return Results;
}
diff --git a/clang-tools-extra/clangd/XRefs.h b/clang-tools-extra/clangd/XRefs.h
index 4dfc530b4fe9c..6c5cb59e25b67 100644
--- a/clang-tools-extra/clangd/XRefs.h
+++ b/clang-tools-extra/clangd/XRefs.h
@@ -151,10 +151,13 @@ std::vector<CallHierarchyIncomingCall>
incomingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index,
ParsedAST &AST, bool ComputeReferenceTags = true);
+/// \p AST may be null when \p ComputeReferenceTags is false, in which case
+/// only index-based function call edges are returned.
std::vector<CallHierarchyOutgoingCall>
-outgoingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index);
+outgoingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index,
+ ParsedAST *AST, bool ComputeReferenceTags = false);
-/// Returns all decls that are referenced in the \p FD except local symbols.
+/// Returns all decls that are referenced in \p FD except local symbols.
llvm::DenseSet<const Decl *> getNonLocalDeclRefs(ParsedAST &AST,
const FunctionDecl *FD);
} // namespace clangd
diff --git a/clang-tools-extra/clangd/index/Ref.h b/clang-tools-extra/clangd/index/Ref.h
index 1241cb8361384..8f1a8bf257b7c 100644
--- a/clang-tools-extra/clangd/index/Ref.h
+++ b/clang-tools-extra/clangd/index/Ref.h
@@ -69,12 +69,12 @@ enum class RefKind : uint8_t {
All = Declaration | Definition | Reference | Spelled | Call,
};
-inline RefKind operator|(RefKind L, RefKind R) {
+inline constexpr RefKind operator|(RefKind L, RefKind R) {
return static_cast<RefKind>(static_cast<uint8_t>(L) |
static_cast<uint8_t>(R));
}
inline RefKind &operator|=(RefKind &L, RefKind R) { return L = L | R; }
-inline RefKind operator&(RefKind A, RefKind B) {
+inline constexpr RefKind operator&(RefKind A, RefKind B) {
return static_cast<RefKind>(static_cast<uint8_t>(A) &
static_cast<uint8_t>(B));
}
diff --git a/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp b/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp
index ff6be2ca875ad..be1ebfeb4746a 100644
--- a/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp
+++ b/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp
@@ -302,7 +302,7 @@ TEST(CallHierarchy, OutgoingOneFile) {
std::vector<CallHierarchyItem> Items =
prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
ASSERT_THAT(Items, ElementsAre(withName("caller3")));
- auto OugoingLevel1 = outgoingCalls(Items[0], Index.get());
+ auto OugoingLevel1 = outgoingCalls(Items[0], Index.get(), &AST);
ASSERT_THAT(
OugoingLevel1,
ElementsAre(
@@ -311,23 +311,73 @@ TEST(CallHierarchy, OutgoingOneFile) {
AllOf(to(AllOf(withName("caller2"), withDetail("caller2"))),
oFromRanges(Source.range("Caller2")))));
- auto OutgoingLevel2 = outgoingCalls(OugoingLevel1[1].to, Index.get());
+ auto OutgoingLevel2 = outgoingCalls(OugoingLevel1[1].to, Index.get(), &AST);
ASSERT_THAT(
OutgoingLevel2,
ElementsAre(AllOf(
to(AllOf(withName("caller1"), withDetail("ns::Foo::caller1"))),
oFromRanges(Source.range("Caller1A"), Source.range("Caller1B")))));
- auto OutgoingLevel3 = outgoingCalls(OutgoingLevel2[0].to, Index.get());
+ auto OutgoingLevel3 = outgoingCalls(OutgoingLevel2[0].to, Index.get(), &AST);
ASSERT_THAT(
OutgoingLevel3,
ElementsAre(AllOf(to(AllOf(withName("callee"), withDetail("callee"))),
oFromRanges(Source.range("Callee")))));
- auto OutgoingLevel4 = outgoingCalls(OutgoingLevel3[0].to, Index.get());
+ auto OutgoingLevel4 = outgoingCalls(OutgoingLevel3[0].to, Index.get(), &AST);
EXPECT_THAT(OutgoingLevel4, IsEmpty());
}
+TEST(CallHierarchy, OutgoingWithReferenceTagsSupport) {
+ Annotations Source(R"cpp(
+ void callee();
+ void ca^ller() {
+ $Callee[[callee]]();
+ }
+ )cpp");
+ TestTU TU = TestTU::withCode(Source.code());
+ auto AST = TU.build();
+ auto Index = TU.index();
+
+ std::vector<CallHierarchyItem> Items =
+ prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
+ ASSERT_THAT(Items, ElementsAre(withName("caller")));
+
+ auto OutgoingLevel1 = outgoingCalls(Items[0], Index.get(), &AST,
+ /*ComputeReferenceTags=*/true);
+ ASSERT_THAT(
+ OutgoingLevel1,
+ ElementsAre(
+ AllOf(to(AllOf(withName("callee"),
+ Field(&CallHierarchyItem::referenceTags, IsEmpty()))),
+ oFromRanges(Source.range("Callee")))));
+}
+
+TEST(CallHierarchy, OutgoingWithoutReferenceTagsSupport) {
+ Annotations Source(R"cpp(
+ void callee();
+ void ca^ller() {
+ $Callee[[callee]]();
+ }
+ )cpp");
+ TestTU TU = TestTU::withCode(Source.code());
+ auto AST = TU.build();
+ auto Index = TU.index();
+
+ std::vector<CallHierarchyItem> Items =
+ prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
+ ASSERT_THAT(Items, ElementsAre(withName("caller")));
+
+ auto OutgoingLevel1 = outgoingCalls(Items[0], Index.get(), &AST,
+ /*ComputeReferenceTags=*/false);
+ ASSERT_THAT(
+ OutgoingLevel1,
+ ElementsAre(
+ AllOf(to(AllOf(withName("callee"),
+ Field(&CallHierarchyItem::referenceTags, IsEmpty()))),
+ oFromRanges(Source.range("Callee")))));
+}
+
TEST(CallHierarchy, MultiFileCpp) {
// The test uses a .hh suffix for header files to get clang
// to parse them in C++ mode. .h files are parsed in C mode
@@ -439,7 +489,7 @@ TEST(CallHierarchy, MultiFileCpp) {
ElementsAre(AllOf(
withName("caller3"),
withFile(testPath(IsDeclaration ? "caller3.hh" : "caller3.cc")))));
- auto OutgoingLevel1 = outgoingCalls(Items[0], Index.get());
+ auto OutgoingLevel1 = outgoingCalls(Items[0], Index.get(), &AST);
ASSERT_THAT(
OutgoingLevel1,
// fromRanges are interpreted in the context of Items[0]'s file.
@@ -453,19 +503,19 @@ TEST(CallHierarchy, MultiFileCpp) {
IsDeclaration ? oFromRanges()
: oFromRanges(Caller3C.range("Caller2")))));
- auto OutgoingLevel2 = outgoingCalls(OutgoingLevel1[1].to, Index.get());
+ auto OutgoingLevel2 = outgoingCalls(OutgoingLevel1[1].to, Index.get(), &AST);
ASSERT_THAT(OutgoingLevel2,
ElementsAre(AllOf(
to(AllOf(withName("caller1"), withDetail("nsa::caller1"))),
oFromRanges(Caller2C.range("A"), Caller2C.range("B")))));
- auto OutgoingLevel3 = outgoingCalls(OutgoingLevel2[0].to, Index.get());
+ auto OutgoingLevel3 = outgoingCalls(OutgoingLevel2[0].to, Index.get(), &AST);
ASSERT_THAT(
OutgoingLevel3,
ElementsAre(AllOf(to(AllOf(withName("callee"), withDetail("callee"))),
oFromRanges(Caller1C.range()))));
- auto OutgoingLevel4 = outgoingCalls(OutgoingLevel3[0].to, Index.get());
+ auto OutgoingLevel4 = outgoingCalls(OutgoingLevel3[0].to, Index.get(), &AST);
EXPECT_THAT(OutgoingLevel4, IsEmpty());
};
@@ -875,6 +925,309 @@ TEST(CallHierarchy, HierarchyOnHeaderVarWithWriteReference) {
ElementsAre(AllOf(from(AllOf(
withName("caller"),
withReferenceTags(ReferenceTag::Write))))));
+
+TEST(CallHierarchy, OutgoingFieldWithReadReference) {
+ Annotations Source(R"cpp(
+ struct Vars {
+ int var1 = 1;
+ };
+ void ca^ller() {
+ Vars values;
+ int foo = values.var1;
+ }
+ )cpp");
+ TestTU TU = TestTU::withCode(Source.code());
+ auto AST = TU.build();
+ auto Index = TU.index();
+
+ std::vector<CallHierarchyItem> Items =
+ prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
+ ASSERT_THAT(Items, ElementsAre(withName("caller")));
+
+ auto OutgoingLevel1 = outgoingCalls(Items[0], Index.get(), &AST,
+ /*ComputeReferenceTags=*/true);
+ ASSERT_THAT(OutgoingLevel1,
+ ElementsAre(AllOf(to(AllOf(
+ withName("var1"), withReferenceTags(ReferenceTag::Read))))));
+}
+
+TEST(CallHierarchy, OutgoingVarWithReadReference) {
+ Annotations Source(R"cpp(
+ int var = 1;
+ void ca^ller() {
+ int x = 0;
+ x = var;
+ }
+ )cpp");
+ TestTU TU = TestTU::withCode(Source.code());
+ auto AST = TU.build();
+ auto Index = TU.index();
+
+ std::vector<CallHierarchyItem> Items =
+ prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
+ ASSERT_THAT(Items, ElementsAre(withName("caller")));
+
+ auto OutgoingLevel1 = outgoingCalls(Items[0], Index.get(), &AST,
+ /*ComputeReferenceTags=*/true);
+ ASSERT_THAT(OutgoingLevel1,
+ ElementsAre(AllOf(to(AllOf(
+ withName("var"), withReferenceTags(ReferenceTag::Read))))));
+}
+
+TEST(CallHierarchy, OutgoingVarWithWriteReference) {
+ Annotations Source(R"cpp(
+ int var = 1;
+ void ca^ller() {
+ var = 2;
+ }
+ )cpp");
+ TestTU TU = TestTU::withCode(Source.code());
+ auto AST = TU.build();
+ auto Index = TU.index();
+
+ std::vector<CallHierarchyItem> Items =
+ prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
+ ASSERT_THAT(Items, ElementsAre(withName("caller")));
+
+ auto OutgoingLevel1 = outgoingCalls(Items[0], Index.get(), &AST,
+ /*ComputeReferenceTags=*/true);
+ ASSERT_THAT(OutgoingLevel1,
+ ElementsAre(AllOf(to(AllOf(
+ withName("var"), withReferenceTags(ReferenceTag::Write))))));
+}
+
+TEST(CallHierarchy, OutgoingVarWithoutReferenceTagsSupport) {
+ Annotations Source(R"cpp(
+ int var = 1;
+ void ca^ller() {
+ var = 2;
+ }
+ )cpp");
+ TestTU TU = TestTU::withCode(Source.code());
+ auto AST = TU.build();
+ auto Index = TU.index();
+
+ std::vector<CallHierarchyItem> Items =
+ prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
+ ASSERT_THAT(Items, ElementsAre(withName("caller")));
+
+ auto OutgoingLevel1 = outgoingCalls(Items[0], Index.get(), &AST,
+ /*ComputeReferenceTags=*/false);
+ EXPECT_THAT(OutgoingLevel1, IsEmpty());
+}
+
+TEST(CallHierarchy, OutgoingClassMemberWithWriteReference) {
+ Annotations Source(R"cpp(
+ class MyClass {
+ public:
+ void ca^ller() {
+ $Write[[var]] = 2;
+ }
+ int var = 1;
+ };
+ )cpp");
+ TestTU TU = TestTU::withCode(Source.code());
+ auto AST = TU.build();
+ auto Index = TU.index();
+
+ std::vector<CallHierarchyItem> Items =
+ prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
+ ASSERT_THAT(Items, ElementsAre(withName("caller")));
+
+ auto OutgoingLevel1 = outgoingCalls(Items[0], Index.get(), &AST,
+ /*ComputeReferenceTags=*/true);
+ ASSERT_THAT(
+ OutgoingLevel1,
+ ElementsAre(AllOf(
+ to(AllOf(withName("var"), withReferenceTags(ReferenceTag::Write))),
+ oFromRanges(Source.range("Write")))));
+}
+
+TEST(CallHierarchy, OutgoingClassMemberWithWriteReferenceInCtorInitList) {
+ Annotations Source(R"cpp(
+ class MyClass {
+ int var;
+ public:
+ MyCl^ass() : $Write[[var]](1) {}
+ };
+ )cpp");
+ TestTU TU = TestTU::withCode(Source.code());
+ auto AST = TU.build();
+ auto Index = TU.index();
+
+ std::vector<CallHierarchyItem> Items =
+ prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
+ ASSERT_THAT(Items, ElementsAre(withName("MyClass")));
+
+ auto OutgoingLevel1 = outgoingCalls(Items[0], Index.get(), &AST,
+ /*ComputeReferenceTags=*/true);
+ ASSERT_THAT(
+ OutgoingLevel1,
+ ElementsAre(AllOf(
+ to(AllOf(withName("var"), withReferenceTags(ReferenceTag::Write))),
+ oFromRanges(Source.range("Write")))));
+}
+
+TEST(CallHierarchy, OutgoingVarWithUnaryReadWriteReference) {
+ Annotations Source(R"cpp(
+ int var = 1;
+ void ca^ller() {
+ $ReadWrite[[var]]++;
+ }
+ )cpp");
+ TestTU TU = TestTU::withCode(Source.code());
+ auto AST = TU.build();
+ auto Index = TU.index();
+
+ std::vector<CallHierarchyItem> Items =
+ prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
+ ASSERT_THAT(Items, ElementsAre(withName("caller")));
+
+ auto OutgoingLevel1 = outgoingCalls(Items[0], Index.get(), &AST,
+ /*ComputeReferenceTags=*/true);
+ ASSERT_THAT(
+ OutgoingLevel1,
+ ElementsAre(AllOf(
+ to(AllOf(withName("var"),
+ withReferenceTags(ReferenceTag::Write, ReferenceTag::Read))),
+ oFromRanges(Source.range("ReadWrite")))));
+}
+
+TEST(CallHierarchy, OutgoingVarWithCompoundAssignmentReference) {
+ // Compound assignment (e.g. +=) is both a read and a write.
+ Annotations Source(R"cpp(
+ int var = 1;
+ void ca^ller() {
+ $ReadWrite[[var]] += 2;
+ }
+ )cpp");
+ TestTU TU = TestTU::withCode(Source.code());
+ auto AST = TU.build();
+ auto Index = TU.index();
+
+ std::vector<CallHierarchyItem> Items =
+ prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
+ ASSERT_THAT(Items, ElementsAre(withName("caller")));
+
+ auto OutgoingLevel1 = outgoingCalls(Items[0], Index.get(), &AST,
+ /*ComputeReferenceTags=*/true);
+ ASSERT_THAT(
+ OutgoingLevel1,
+ ElementsAre(AllOf(
+ to(AllOf(withName("var"),
+ withReferenceTags(ReferenceTag::Write, ReferenceTag::Read))),
+ oFromRanges(Source.range("ReadWrite")))));
+}
+
+TEST(CallHierarchy, OutgoingHeaderVarWithWriteReference) {
+ // Verifies that reference tags are computed even when the referenced symbol
+ // lives in a header file.
+ Annotations Header(R"cpp(
+ int var = 1;
+ )cpp");
+ Annotations Source(R"cpp(
+ #include "HeaderSymbol.h"
+ void ca^ller() {
+ $Write[[var]] = 2;
+ }
+ )cpp");
+ TestTU TU = TestTU::withCode(Source.code());
+ TU.HeaderFilename = "HeaderSymbol.h";
+ TU.HeaderCode = Header.code();
+ auto AST = TU.build();
+ auto Index = TU.index();
+
+ std::vector<CallHierarchyItem> Items =
+ prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
+ ASSERT_THAT(Items, ElementsAre(withName("caller")));
+
+ auto OutgoingLevel1 = outgoingCalls(Items[0], Index.get(), &AST,
+ /*ComputeReferenceTags=*/true);
+ ASSERT_THAT(
+ OutgoingLevel1,
+ ElementsAre(AllOf(
+ to(AllOf(withName("var"), withReferenceTags(ReferenceTag::Write))),
+ oFromRanges(Source.range("Write")))));
+}
+
+TEST(CallHierarchy, OutgoingMixedVarAndFunctionKeepsFunctionUntagged) {
+ Annotations Source(R"cpp( int var = 0;
+ void callee();
+ void ca^ller() {
+ $Write[[var]] = 1;
+ $Call[[callee]]();
+ }
+ )cpp");
+ TestTU TU = TestTU::withCode(Source.code());
+ auto AST = TU.build();
+ auto Index = TU.index();
+
+ std::vector<CallHierarchyItem> Items =
+ prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
+ ASSERT_THAT(Items, ElementsAre(withName("caller")));
+
+ auto OutgoingLevel1 = outgoingCalls(Items[0], Index.get(), &AST,
+ /*ComputeReferenceTags=*/true);
+ ASSERT_THAT(
+ OutgoingLevel1,
+ UnorderedElementsAre(
+ AllOf(to(AllOf(withName("var"),
+ withReferenceTags(ReferenceTag::Write))),
+ oFromRanges(Source.range("Write"))),
+ AllOf(to(AllOf(withName("callee"),
+ Field(&CallHierarchyItem::referenceTags, IsEmpty()))),
+ oFromRanges(Source.range("Call")))));
+}
+
+TEST(CallHierarchy, OutgoingVarAggregatesReadAndWriteAcrossStatements) {
+ Annotations Source(R"cpp( int var = 0;
+ void ca^ller() {
+ int x = $Read[[var]];
+ $Write[[var]] = x;
+ }
+ )cpp");
+ TestTU TU = TestTU::withCode(Source.code());
+ auto AST = TU.build();
+ auto Index = TU.index();
+
+ std::vector<CallHierarchyItem> Items =
+ prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
+ ASSERT_THAT(Items, ElementsAre(withName("caller")));
+
+ auto OutgoingLevel1 = outgoingCalls(Items[0], Index.get(), &AST,
+ /*ComputeReferenceTags=*/true);
+ ASSERT_THAT(
+ OutgoingLevel1,
+ ElementsAre(AllOf(
+ to(AllOf(withName("var"),
+ withReferenceTags(ReferenceTag::Read, ReferenceTag::Write))),
+ oFromRanges(Source.range("Read"), Source.range("Write")))));
+}
+
+TEST(CallHierarchy, OutgoingVarRepeatedReadsProduceSingleItem) {
+ Annotations Source(R"cpp( int var = 0;
+ void ca^ller() {
+ int a = $Read1[[var]];
+ int b = $Read2[[var]];
+ (void)a;
+ (void)b;
+ }
+ )cpp");
+ TestTU TU = TestTU::withCode(Source.code());
+ auto AST = TU.build();
+ auto Index = TU.index();
+
+ std::vector<CallHierarchyItem> Items =
+ prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
+ ASSERT_THAT(Items, ElementsAre(withName("caller")));
+
+ auto OutgoingLevel1 = outgoingCalls(Items[0], Index.get(), &AST,
+ /*ComputeReferenceTags=*/true);
+ ASSERT_THAT(
+ OutgoingLevel1,
+ ElementsAre(AllOf(
+ to(AllOf(withName("var"), withReferenceTags(ReferenceTag::Read))),
+ oFromRanges(Source.range("Read1"), Source.range("Read2")))));
}
TEST(CallHierarchy, HierarchyOnEnumConstant) {
diff --git a/clang-tools-extra/clangd/unittests/ClangdLSPServerTests.cpp b/clang-tools-extra/clangd/unittests/ClangdLSPServerTests.cpp
index bd5e07f24dcbc..4b4af97939a4c 100644
--- a/clang-tools-extra/clangd/unittests/ClangdLSPServerTests.cpp
+++ b/clang-tools-extra/clangd/unittests/ClangdLSPServerTests.cpp
@@ -327,9 +327,9 @@ TEST_F(LSPTest, IncomingCallsWithReferenceTagsSupport) {
Client.didOpen("foo.cpp", Code.code());
auto Items = Client
.call("textDocument/prepareCallHierarchy",
- llvm::json::Object{{
- "textDocument", Client.documentID("foo.cpp")},
- {"position", Code.point()}})
+ llvm::json::Object{
+ {"textDocument", Client.documentID("foo.cpp")},
+ {"position", Code.point()}})
.takeValue();
auto FirstItem = (*Items.getAsArray())[0];
auto Calls = Client
@@ -372,6 +372,58 @@ TEST_F(LSPTest, IncomingCallsWithoutReferenceTagsSupport) {
EXPECT_FALSE(From.get("referenceTags"));
}
+TEST_F(LSPTest, OutgoingVarCallsWithReferenceTagsSupport) {
+ Annotations Code(R"cpp(
+ int var = 1;
+ void callee();
+ void ca^ller() {
+ var = 2;
+ callee();
+ }
+ )cpp");
+ auto &Client = start(llvm::json::Object{{
+ "capabilities",
+ llvm::json::Object{{
+ "textDocument",
+ llvm::json::Object{{
+ "callHierarchy",
+ llvm::json::Object{{"referenceTagsSupport", true}},
+ }},
+ }},
+ }});
+ Client.didOpen("foo.cpp", Code.code());
+ auto Items = Client
+ .call("textDocument/prepareCallHierarchy",
+ llvm::json::Object{
+ {"textDocument", Client.documentID("foo.cpp")},
+ {"position", Code.point()}})
+ .takeValue();
+ auto FirstItem = (*Items.getAsArray())[0];
+ auto Calls = Client
+ .call("callHierarchy/outgoingCalls",
+ llvm::json::Object{{"item", FirstItem}})
+ .takeValue();
+ auto CallArray = Calls.getAsArray();
+ ASSERT_EQ(CallArray->size(), 2u);
+
+ {
+ auto FirstCall = *(*CallArray)[0].getAsObject();
+ auto To = *FirstCall["to"].getAsObject();
+
+ EXPECT_EQ(To["name"], "var");
+ EXPECT_EQ(To["referenceTags"], llvm::json::Value(llvm::json::Array{
+ static_cast<int>(ReferenceTag::Write)}));
+ }
+ {
+ auto SecondCall = *(*CallArray)[1].getAsObject();
+ auto To = *SecondCall["to"].getAsObject();
+
+ EXPECT_EQ(To["name"], "callee");
+ // Function calls are neither Read nor Write accesses, so no referenceTags.
+ EXPECT_FALSE(To.get("referenceTags"));
+ }
+}
+
TEST_F(LSPTest, CDBConfigIntegration) {
auto CfgProvider =
config::Provider::fromAncestorRelativeYAMLFiles(".clangd", FS);
>From 914239f311af3a32803fb1f708092b25812779bf Mon Sep 17 00:00:00 2001
From: Dimitri Ratz <dimitri.ratz at protonmail.com>
Date: Wed, 13 May 2026 18:11:55 +0200
Subject: [PATCH 10/11] [clangd] fix format.
---
clang-tools-extra/clangd/ClangdServer.cpp | 15 +++++-----
clang-tools-extra/clangd/Protocol.h | 1 -
clang-tools-extra/clangd/XRefs.cpp | 20 ++++++-------
.../clangd/unittests/CallHierarchyTests.cpp | 30 +++++++++++--------
.../clangd/unittests/ClangdLSPServerTests.cpp | 11 ++++---
5 files changed, 38 insertions(+), 39 deletions(-)
diff --git a/clang-tools-extra/clangd/ClangdServer.cpp b/clang-tools-extra/clangd/ClangdServer.cpp
index a14891008799f..dd164a0b501bb 100644
--- a/clang-tools-extra/clangd/ClangdServer.cpp
+++ b/clang-tools-extra/clangd/ClangdServer.cpp
@@ -918,8 +918,7 @@ void ClangdServer::incomingCalls(
this](llvm::Expected<InputsAndAST> InpAST) mutable {
if (!InpAST)
return CB(InpAST.takeError());
- CB(clangd::incomingCalls(Item, Index, InpAST->AST,
- ComputeReferenceTags));
+ CB(clangd::incomingCalls(Item, Index, InpAST->AST, ComputeReferenceTags));
};
WorkScheduler->runWithAST("Incoming Calls", File, std::move(Action));
}
@@ -941,12 +940,12 @@ void ClangdServer::outgoingCalls(
if (!ComputeReferenceTags) {
// Fast path: reference tags are not requested, so no AST is needed.
// Dispatch as an index-only task to avoid unnecessary parse latency.
- WorkScheduler->run("Outgoing Calls", "",
- [Item, CB = std::move(CB), this]() mutable {
- CB(clangd::outgoingCalls(Item, Index,
- /*AST=*/nullptr,
- /*ComputeReferenceTags=*/false));
- });
+ WorkScheduler->run(
+ "Outgoing Calls", "", [Item, CB = std::move(CB), this]() mutable {
+ CB(clangd::outgoingCalls(Item, Index,
+ /*AST=*/nullptr,
+ /*ComputeReferenceTags=*/false));
+ });
return;
}
auto Action = [Item, CB = std::move(CB),
diff --git a/clang-tools-extra/clangd/Protocol.h b/clang-tools-extra/clangd/Protocol.h
index 56738e3e93d57..27ac6659f7e3e 100644
--- a/clang-tools-extra/clangd/Protocol.h
+++ b/clang-tools-extra/clangd/Protocol.h
@@ -1570,7 +1570,6 @@ struct TypeHierarchyItem {
/// The kind of this item.
SymbolKind kind;
-
/// More detail for this item, e.g. the signature of a function.
std::optional<std::string> detail;
diff --git a/clang-tools-extra/clangd/XRefs.cpp b/clang-tools-extra/clangd/XRefs.cpp
index b80990eaa789f..56fbc031440bf 100644
--- a/clang-tools-extra/clangd/XRefs.cpp
+++ b/clang-tools-extra/clangd/XRefs.cpp
@@ -1928,14 +1928,13 @@ static std::vector<ReferenceTag> analyseParameterUsage(const FunctionDecl *FD,
/// Visitor that determines read/write access patterns for a set of variables
/// in a single traversal of a function body. This avoids the O(N * body_size)
/// cost of calling analyseParameterUsage once per variable.
-class BulkVarUsageVisitor
- : public RecursiveASTVisitor<BulkVarUsageVisitor> {
+class BulkVarUsageVisitor : public RecursiveASTVisitor<BulkVarUsageVisitor> {
public:
/// Per-symbol result: (hasRead, hasWrite).
llvm::DenseMap<SymbolID, std::pair<bool, bool>> Usage;
- BulkVarUsageVisitor(llvm::ArrayRef<std::pair<SymbolID, const ValueDecl *>>
- Targets) {
+ BulkVarUsageVisitor(
+ llvm::ArrayRef<std::pair<SymbolID, const ValueDecl *>> Targets) {
for (const auto &[ID, VD] : Targets)
Usage.try_emplace(ID, false, false);
}
@@ -2688,8 +2687,7 @@ static const NamedDecl *getNamedDeclFromSymbol(const Symbol &Sym,
const auto &SM = AST.getSourceManager();
auto CurLoc = sourceLocationInMainFile(SM, SymLoc->range.start);
if (CurLoc) {
- auto Decls =
- getDeclAtPosition(const_cast<ParsedAST &>(AST), *CurLoc, {});
+ auto Decls = getDeclAtPosition(const_cast<ParsedAST &>(AST), *CurLoc, {});
if (!Decls.empty())
return Decls[0];
} else {
@@ -2793,7 +2791,8 @@ incomingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index,
llvm::consumeError(RefLoc.takeError());
continue;
}
- for (const NamedDecl *AtPos : getDeclAtPosition(AST, *RefLoc, {})) {
+ for (const NamedDecl *AtPos :
+ getDeclAtPosition(AST, *RefLoc, {})) {
if (const auto *Resolved =
llvm::dyn_cast<clang::ValueDecl>(AtPos)) {
VD = Resolved;
@@ -2957,8 +2956,8 @@ outgoingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index,
[&](ReferenceLoc Ref) {
if (Ref.IsDecl)
return;
- auto Loc = makeLocation(AST->getASTContext(), Ref.NameLoc,
- Item.uri.file());
+ auto Loc =
+ makeLocation(AST->getASTContext(), Ref.NameLoc, Item.uri.file());
if (!Loc)
return;
for (const Decl *D : Ref.Targets) {
@@ -3020,8 +3019,7 @@ outgoingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index,
Position Best{INT_MAX, INT_MAX};
for (const auto &R : Ranges)
if (R.start.line < Best.line ||
- (R.start.line == Best.line &&
- R.start.character < Best.character))
+ (R.start.line == Best.line && R.start.character < Best.character))
Best = R.start;
return Best;
};
diff --git a/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp b/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp
index be1ebfeb4746a..ead7907c852f3 100644
--- a/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp
+++ b/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp
@@ -503,19 +503,22 @@ TEST(CallHierarchy, MultiFileCpp) {
IsDeclaration ? oFromRanges()
: oFromRanges(Caller3C.range("Caller2")))));
- auto OutgoingLevel2 = outgoingCalls(OutgoingLevel1[1].to, Index.get(), &AST);
+ auto OutgoingLevel2 =
+ outgoingCalls(OutgoingLevel1[1].to, Index.get(), &AST);
ASSERT_THAT(OutgoingLevel2,
ElementsAre(AllOf(
to(AllOf(withName("caller1"), withDetail("nsa::caller1"))),
oFromRanges(Caller2C.range("A"), Caller2C.range("B")))));
- auto OutgoingLevel3 = outgoingCalls(OutgoingLevel2[0].to, Index.get(), &AST);
+ auto OutgoingLevel3 =
+ outgoingCalls(OutgoingLevel2[0].to, Index.get(), &AST);
ASSERT_THAT(
OutgoingLevel3,
ElementsAre(AllOf(to(AllOf(withName("callee"), withDetail("callee"))),
oFromRanges(Caller1C.range()))));
- auto OutgoingLevel4 = outgoingCalls(OutgoingLevel3[0].to, Index.get(), &AST);
+ auto OutgoingLevel4 =
+ outgoingCalls(OutgoingLevel3[0].to, Index.get(), &AST);
EXPECT_THAT(OutgoingLevel4, IsEmpty());
};
@@ -798,9 +801,9 @@ TEST(CallHierarchy, HierarchyOnVarWithoutReferenceTagsSupport) {
/*ComputeReferenceTags=*/false);
ASSERT_FALSE(IncomingLevel1.empty());
EXPECT_THAT(IncomingLevel1,
- ElementsAre(AllOf(from(Field(&CallHierarchyItem::name, "caller")),
- from(Field(&CallHierarchyItem::referenceTags,
- IsEmpty())))));
+ ElementsAre(AllOf(
+ from(Field(&CallHierarchyItem::name, "caller")),
+ from(Field(&CallHierarchyItem::referenceTags, IsEmpty())))));
}
TEST(CallHierarchy, HierarchyOnClassMemberWithWriteReference) {
@@ -893,9 +896,9 @@ TEST(CallHierarchy, HierarchyOnVarWithCompoundAssignmentReference) {
ASSERT_FALSE(IncomingLevel1.empty());
EXPECT_THAT(
IncomingLevel1,
- UnorderedElementsAre(AllOf(from(AllOf(
- withName("caller"),
- withReferenceTags(ReferenceTag::Write, ReferenceTag::Read))))));
+ UnorderedElementsAre(AllOf(from(
+ AllOf(withName("caller"),
+ withReferenceTags(ReferenceTag::Write, ReferenceTag::Read))))));
}
TEST(CallHierarchy, HierarchyOnHeaderVarWithWriteReference) {
@@ -921,10 +924,11 @@ TEST(CallHierarchy, HierarchyOnHeaderVarWithWriteReference) {
ASSERT_THAT(Items, ElementsAre(withName("var")));
auto IncomingLevel1 = incomingCalls(Items[0], Index.get(), AST);
ASSERT_FALSE(IncomingLevel1.empty());
- EXPECT_THAT(IncomingLevel1,
- ElementsAre(AllOf(from(AllOf(
- withName("caller"),
- withReferenceTags(ReferenceTag::Write))))));
+ EXPECT_THAT(
+ IncomingLevel1,
+ ElementsAre(AllOf(from(
+ AllOf(withName("caller"), withReferenceTags(ReferenceTag::Write))))));
+}
TEST(CallHierarchy, OutgoingFieldWithReadReference) {
Annotations Source(R"cpp(
diff --git a/clang-tools-extra/clangd/unittests/ClangdLSPServerTests.cpp b/clang-tools-extra/clangd/unittests/ClangdLSPServerTests.cpp
index 4b4af97939a4c..dbf81923a26c3 100644
--- a/clang-tools-extra/clangd/unittests/ClangdLSPServerTests.cpp
+++ b/clang-tools-extra/clangd/unittests/ClangdLSPServerTests.cpp
@@ -340,9 +340,8 @@ TEST_F(LSPTest, IncomingCallsWithReferenceTagsSupport) {
auto From = *FirstCall["from"].getAsObject();
EXPECT_EQ(From["name"], "caller");
- EXPECT_EQ(From["referenceTags"],
- llvm::json::Value(llvm::json::Array{static_cast<int>(
- ReferenceTag::Write)}));
+ EXPECT_EQ(From["referenceTags"], llvm::json::Value(llvm::json::Array{
+ static_cast<int>(ReferenceTag::Write)}));
}
TEST_F(LSPTest, IncomingCallsWithoutReferenceTagsSupport) {
@@ -356,9 +355,9 @@ TEST_F(LSPTest, IncomingCallsWithoutReferenceTagsSupport) {
Client.didOpen("foo.cpp", Code.code());
auto Items = Client
.call("textDocument/prepareCallHierarchy",
- llvm::json::Object{{
- "textDocument", Client.documentID("foo.cpp")},
- {"position", Code.point()}})
+ llvm::json::Object{
+ {"textDocument", Client.documentID("foo.cpp")},
+ {"position", Code.point()}})
.takeValue();
auto FirstItem = (*Items.getAsArray())[0];
auto Calls = Client
>From 71e8b5b18a382e482956d29b6fd0aeacee7fd567 Mon Sep 17 00:00:00 2001
From: Dimitri Ratz <dimitri.ratz at protonmail.com>
Date: Sun, 24 May 2026 00:20:16 +0200
Subject: [PATCH 11/11] [clangd] Add LSP 3.18 textDocument/references
referenceItems support Implement support for the LSP 3.18 PR #2226
textDocument/references Reference item response type. When the client
announces textDocument.references.referenceItemsSupport=true, clangd returns
Reference[] objects (with nested 'location' and optional 'referenceTags')
instead of the legacy flat Location[] array. Changes: - Protocol.h/cpp: Add
'Reference' struct and JSON serializer; parse
'textDocument.references.referenceItemsSupport' client capability. -
XRefs.h/cpp: Add 'ReferenceTags' field to ReferencesResult::Reference;
introduce 6-arg findReferences() overload with ComputeReferenceTags flag;
keep 5-arg overload for backward compatibility. - ClangdServer.h/cpp: Thread
ComputeReferenceTags flag through to XRefs. - ClangdLSPServer.h/cpp: Store
SupportsReferenceItems capability flag; in onReference() emit Reference[]
or legacy ReferenceLocation[] depending on client capability. - Tests: Add
LSPTest.ReferencesReturnReferenceItemsWithTags and
LSPTest.ReferencesReturnLegacyLocationWithoutReferenceItemsSupport.
---
clang-tools-extra/clangd/ClangdLSPServer.cpp | 26 ++++++-
clang-tools-extra/clangd/ClangdLSPServer.h | 5 +-
clang-tools-extra/clangd/ClangdServer.cpp | 7 +-
clang-tools-extra/clangd/ClangdServer.h | 3 +-
clang-tools-extra/clangd/Protocol.cpp | 7 ++
clang-tools-extra/clangd/Protocol.h | 12 +++
clang-tools-extra/clangd/XRefs.cpp | 13 ++++
clang-tools-extra/clangd/XRefs.h | 7 ++
.../clangd/unittests/ClangdLSPServerTests.cpp | 77 +++++++++++++++++++
9 files changed, 149 insertions(+), 8 deletions(-)
diff --git a/clang-tools-extra/clangd/ClangdLSPServer.cpp b/clang-tools-extra/clangd/ClangdLSPServer.cpp
index 289fda9c00550..9b8ace3b5ef5a 100644
--- a/clang-tools-extra/clangd/ClangdLSPServer.cpp
+++ b/clang-tools-extra/clangd/ClangdLSPServer.cpp
@@ -538,6 +538,7 @@ void ClangdLSPServer::onInitialize(const InitializeParams &Params,
Params.capabilities.HierarchicalDocumentSymbol;
SupportsReferenceContainer = Params.capabilities.ReferenceContainer;
SupportsReferenceTags = Params.capabilities.ReferenceTagsSupport;
+ SupportsReferenceItems = Params.capabilities.ReferenceItemsSupport;
SupportFileStatus = Params.initializationOptions.FileStatus;
SupportsDocumentChanges = Params.capabilities.DocumentChanges;
SupportsChangeAnnotation = Params.capabilities.ChangeAnnotation;
@@ -1484,20 +1485,37 @@ void ClangdLSPServer::onChangeConfiguration(
void ClangdLSPServer::onReference(
const ReferenceParams &Params,
- Callback<std::vector<ReferenceLocation>> Reply) {
+ Callback<llvm::json::Value> Reply) {
Server->findReferences(Params.textDocument.uri.file(), Params.position,
Opts.ReferencesLimit, SupportsReferenceContainer,
+ /*ComputeReferenceTags=*/SupportsReferenceItems,
[Reply = std::move(Reply),
- IncludeDecl(Params.context.includeDeclaration)](
+ IncludeDecl(Params.context.includeDeclaration),
+ ReturnReferenceItems(SupportsReferenceItems)](
llvm::Expected<ReferencesResult> Refs) mutable {
if (!Refs)
return Reply(Refs.takeError());
// Filter out declarations if the client asked.
+ if (ReturnReferenceItems) {
+ std::vector<Reference> Result;
+ Result.reserve(Refs->References.size());
+ for (auto &Ref : Refs->References) {
+ bool IsDecl = Ref.Attributes &
+ ReferencesResult::Declaration;
+ if (!(IncludeDecl || !IsDecl))
+ continue;
+ Reference Item;
+ Item.location = std::move(Ref.Loc);
+ Item.referenceTags = std::move(Ref.ReferenceTags);
+ Result.push_back(std::move(Item));
+ }
+ return Reply(std::move(Result));
+ }
std::vector<ReferenceLocation> Result;
Result.reserve(Refs->References.size());
for (auto &Ref : Refs->References) {
- bool IsDecl =
- Ref.Attributes & ReferencesResult::Declaration;
+ bool IsDecl = Ref.Attributes &
+ ReferencesResult::Declaration;
if (IncludeDecl || !IsDecl)
Result.push_back(std::move(Ref.Loc));
}
diff --git a/clang-tools-extra/clangd/ClangdLSPServer.h b/clang-tools-extra/clangd/ClangdLSPServer.h
index 860632476cbe4..ffd62968a2a7f 100644
--- a/clang-tools-extra/clangd/ClangdLSPServer.h
+++ b/clang-tools-extra/clangd/ClangdLSPServer.h
@@ -133,7 +133,7 @@ class ClangdLSPServer : private ClangdServer::Callbacks,
Callback<std::vector<Location>>);
void onGoToImplementation(const TextDocumentPositionParams &,
Callback<std::vector<Location>>);
- void onReference(const ReferenceParams &, Callback<std::vector<ReferenceLocation>>);
+ void onReference(const ReferenceParams &, Callback<llvm::json::Value>);
void onSwitchSourceHeader(const TextDocumentIdentifier &,
Callback<std::optional<URIForFile>>);
void onDocumentHighlight(const TextDocumentPositionParams &,
@@ -301,6 +301,9 @@ class ClangdLSPServer : private ClangdServer::Callbacks,
bool SupportsReferenceContainer = false;
/// Whether the client supports reference tags on hierarchy/reference items.
bool SupportsReferenceTags = false;
+ /// Whether the client supports and prefers LSP 3.18 Reference[] results
+ /// for textDocument/references.
+ bool SupportsReferenceItems = false;
/// Which kind of markup should we use in textDocument/hover responses.
MarkupKind HoverContentFormat = MarkupKind::PlainText;
/// Whether the client supports offsets for parameter info labels.
diff --git a/clang-tools-extra/clangd/ClangdServer.cpp b/clang-tools-extra/clangd/ClangdServer.cpp
index dd164a0b501bb..2f0bdf74b0d84 100644
--- a/clang-tools-extra/clangd/ClangdServer.cpp
+++ b/clang-tools-extra/clangd/ClangdServer.cpp
@@ -1027,12 +1027,15 @@ void ClangdServer::findImplementations(
void ClangdServer::findReferences(PathRef File, Position Pos, uint32_t Limit,
bool AddContainer,
+ bool ComputeReferenceTags,
Callback<ReferencesResult> CB) {
- auto Action = [Pos, Limit, AddContainer, CB = std::move(CB),
+ auto Action = [Pos, Limit, AddContainer, ComputeReferenceTags,
+ CB = std::move(CB),
this](llvm::Expected<InputsAndAST> InpAST) mutable {
if (!InpAST)
return CB(InpAST.takeError());
- CB(clangd::findReferences(InpAST->AST, Pos, Limit, Index, AddContainer));
+ CB(clangd::findReferences(InpAST->AST, Pos, Limit, Index, AddContainer,
+ ComputeReferenceTags));
};
WorkScheduler->runWithAST("References", File, std::move(Action));
diff --git a/clang-tools-extra/clangd/ClangdServer.h b/clang-tools-extra/clangd/ClangdServer.h
index fe88281a967f9..20f3f8727840e 100644
--- a/clang-tools-extra/clangd/ClangdServer.h
+++ b/clang-tools-extra/clangd/ClangdServer.h
@@ -336,7 +336,8 @@ class ClangdServer {
/// Retrieve locations for symbol references.
void findReferences(PathRef File, Position Pos, uint32_t Limit,
- bool AddContainer, Callback<ReferencesResult> CB);
+ bool AddContainer, bool ComputeReferenceTags,
+ Callback<ReferencesResult> CB);
/// Run formatting for the \p File with content \p Code.
/// If \p Rng is non-empty, formats only those regions.
diff --git a/clang-tools-extra/clangd/Protocol.cpp b/clang-tools-extra/clangd/Protocol.cpp
index 60dddfcea62d8..3be351a83e89e 100644
--- a/clang-tools-extra/clangd/Protocol.cpp
+++ b/clang-tools-extra/clangd/Protocol.cpp
@@ -172,6 +172,13 @@ llvm::json::Value toJSON(const ReferenceLocation &P) {
return Result;
}
+llvm::json::Value toJSON(const Reference &R) {
+ llvm::json::Object Result{{"location", R.location}};
+ if (!R.referenceTags.empty())
+ Result["referenceTags"] = R.referenceTags;
+ return Result;
+}
+
llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
const ReferenceLocation &L) {
return OS << L.range << '@' << L.uri << " (container: " << L.containerName
diff --git a/clang-tools-extra/clangd/Protocol.h b/clang-tools-extra/clangd/Protocol.h
index 27ac6659f7e3e..bb6a78b8c888d 100644
--- a/clang-tools-extra/clangd/Protocol.h
+++ b/clang-tools-extra/clangd/Protocol.h
@@ -44,6 +44,8 @@
namespace clang {
namespace clangd {
+enum class ReferenceTag;
+
enum class ErrorCode {
// Defined by JSON RPC.
ParseError = -32700,
@@ -238,6 +240,16 @@ struct ReferenceLocation : Location {
llvm::json::Value toJSON(const ReferenceLocation &);
llvm::raw_ostream &operator<<(llvm::raw_ostream &, const ReferenceLocation &);
+/// LSP 3.18 reference item used by textDocument/references when supported.
+struct Reference {
+ /// The location of this reference.
+ Location location;
+
+ /// Optional, one or more tags describing this reference.
+ std::vector<ReferenceTag> referenceTags;
+};
+llvm::json::Value toJSON(const Reference &);
+
using ChangeAnnotationIdentifier = std::string;
// A combination of a LSP standard TextEdit and AnnotatedTextEdit.
struct TextEdit {
diff --git a/clang-tools-extra/clangd/XRefs.cpp b/clang-tools-extra/clangd/XRefs.cpp
index 56fbc031440bf..6cb64b6b9cffe 100644
--- a/clang-tools-extra/clangd/XRefs.cpp
+++ b/clang-tools-extra/clangd/XRefs.cpp
@@ -1486,6 +1486,13 @@ maybeFindIncludeReferences(ParsedAST &AST, Position Pos,
ReferencesResult findReferences(ParsedAST &AST, Position Pos, uint32_t Limit,
const SymbolIndex *Index, bool AddContext) {
+ return findReferences(AST, Pos, Limit, Index, AddContext,
+ /*ComputeReferenceTags=*/false);
+}
+
+ReferencesResult findReferences(ParsedAST &AST, Position Pos, uint32_t Limit,
+ const SymbolIndex *Index, bool AddContext,
+ bool ComputeReferenceTags) {
ReferencesResult Results;
const SourceManager &SM = AST.getSourceManager();
auto MainFilePath = AST.tuPath();
@@ -1587,6 +1594,12 @@ ReferencesResult findReferences(ParsedAST &AST, Position Pos, uint32_t Limit,
ReferencesResult::Reference Result;
Result.Loc.range = Ref.range(SM);
Result.Loc.uri = URIMainFile;
+ if (ComputeReferenceTags) {
+ if (Ref.Role & static_cast<unsigned>(index::SymbolRole::Write))
+ Result.ReferenceTags.push_back(ReferenceTag::Write);
+ if (Ref.Role & static_cast<unsigned>(index::SymbolRole::Read))
+ Result.ReferenceTags.push_back(ReferenceTag::Read);
+ }
if (AddContext)
Result.Loc.containerName =
stringifyContainerForMainFileRef(Ref.Container);
diff --git a/clang-tools-extra/clangd/XRefs.h b/clang-tools-extra/clangd/XRefs.h
index 6c5cb59e25b67..d409e52c62f7d 100644
--- a/clang-tools-extra/clangd/XRefs.h
+++ b/clang-tools-extra/clangd/XRefs.h
@@ -89,6 +89,7 @@ struct ReferencesResult {
};
struct Reference {
ReferenceLocation Loc;
+ std::vector<ReferenceTag> ReferenceTags;
unsigned Attributes = 0;
};
std::vector<Reference> References;
@@ -116,6 +117,12 @@ ReferencesResult findReferences(ParsedAST &AST, Position Pos, uint32_t Limit,
const SymbolIndex *Index = nullptr,
bool AddContext = false);
+/// Returns references and optionally computes read/write tags for main-file
+/// references when \p ComputeReferenceTags is true.
+ReferencesResult findReferences(ParsedAST &AST, Position Pos, uint32_t Limit,
+ const SymbolIndex *Index, bool AddContext,
+ bool ComputeReferenceTags);
+
/// Get info about symbols at \p Pos.
std::vector<SymbolDetails> getSymbolInfo(ParsedAST &AST, Position Pos);
diff --git a/clang-tools-extra/clangd/unittests/ClangdLSPServerTests.cpp b/clang-tools-extra/clangd/unittests/ClangdLSPServerTests.cpp
index dbf81923a26c3..dde93a9353897 100644
--- a/clang-tools-extra/clangd/unittests/ClangdLSPServerTests.cpp
+++ b/clang-tools-extra/clangd/unittests/ClangdLSPServerTests.cpp
@@ -423,6 +423,83 @@ TEST_F(LSPTest, OutgoingVarCallsWithReferenceTagsSupport) {
}
}
+TEST_F(LSPTest, ReferencesReturnReferenceItemsWithTags) {
+ Annotations Code(R"cpp(
+ int var = 1;
+ void caller() {
+ $Write[[v^ar]] = 2;
+ int x = $Read[[var]];
+ }
+ )cpp");
+ auto &Client = start(llvm::json::Object{{
+ "capabilities",
+ llvm::json::Object{{
+ "textDocument",
+ llvm::json::Object{{
+ "references",
+ llvm::json::Object{{"referenceItemsSupport", true}},
+ }},
+ }},
+ }});
+ Client.didOpen("foo.cpp", Code.code());
+ auto Refs = Client
+ .call("textDocument/references",
+ llvm::json::Object{{
+ "textDocument", Client.documentID("foo.cpp")},
+ {"position", Code.point()},
+ {"context", llvm::json::Object{{"includeDeclaration",
+ false}}},
+ })
+ .takeValue();
+
+ auto *RefArray = Refs.getAsArray();
+ ASSERT_TRUE(RefArray);
+ ASSERT_EQ(RefArray->size(), 2u);
+
+ auto First = *(*RefArray)[0].getAsObject();
+ auto FirstLoc = *First["location"].getAsObject();
+ EXPECT_EQ(FirstLoc["uri"], Client.uri("foo.cpp"));
+ EXPECT_EQ(FirstLoc["range"], llvm::json::Value(Code.range("Write")));
+ EXPECT_EQ(First["referenceTags"], llvm::json::Value(llvm::json::Array{
+ static_cast<int>(ReferenceTag::Write)}));
+
+ auto Second = *(*RefArray)[1].getAsObject();
+ auto SecondLoc = *Second["location"].getAsObject();
+ EXPECT_EQ(SecondLoc["uri"], Client.uri("foo.cpp"));
+ EXPECT_EQ(SecondLoc["range"], llvm::json::Value(Code.range("Read")));
+ EXPECT_EQ(Second["referenceTags"], llvm::json::Value(llvm::json::Array{
+ static_cast<int>(ReferenceTag::Read)}));
+}
+
+TEST_F(LSPTest, ReferencesReturnLegacyLocationWithoutReferenceItemsSupport) {
+ Annotations Code(R"cpp(
+ int var = 1;
+ void caller() {
+ $Write[[v^ar]] = 2;
+ }
+ )cpp");
+ auto &Client = start();
+ Client.didOpen("foo.cpp", Code.code());
+ auto Refs = Client
+ .call("textDocument/references",
+ llvm::json::Object{{
+ "textDocument", Client.documentID("foo.cpp")},
+ {"position", Code.point()},
+ {"context", llvm::json::Object{{"includeDeclaration",
+ false}}},
+ })
+ .takeValue();
+
+ auto *RefArray = Refs.getAsArray();
+ ASSERT_TRUE(RefArray);
+ ASSERT_EQ(RefArray->size(), 1u);
+ auto First = *(*RefArray)[0].getAsObject();
+ EXPECT_EQ(First["uri"], Client.uri("foo.cpp"));
+ EXPECT_EQ(First["range"], llvm::json::Value(Code.range("Write")));
+ EXPECT_FALSE(First.get("location"));
+ EXPECT_FALSE(First.get("referenceTags"));
+}
+
TEST_F(LSPTest, CDBConfigIntegration) {
auto CfgProvider =
config::Provider::fromAncestorRelativeYAMLFiles(".clangd", FS);
More information about the cfe-commits
mailing list