struct Reference {
syntax::Token SpelledTok;
index::SymbolRoleSet Role;
+ SymbolID Target;
Range range(const SourceManager &SM) const {
return halfOpenToRange(SM, SpelledTok.range(SM).toCharRange(SM));
SourceLocation Loc,
index::IndexDataConsumer::ASTNodeInfo ASTNode) override {
const SourceManager &SM = AST.getSourceManager();
- if (!isInsideMainFile(Loc, SM) ||
- TargetIDs.find(getSymbolID(D)) == TargetIDs.end())
+ if (!isInsideMainFile(Loc, SM))
+ return true;
+ SymbolID ID = getSymbolID(D);
+ if (!TargetIDs.contains(ID))
return true;
const auto &TB = AST.getTokens();
Loc = SM.getFileLoc(Loc);
if (const auto *Tok = TB.spelledTokenAt(Loc))
- References.push_back({*Tok, Roles});
+ References.push_back({*Tok, Roles, ID});
return true;
}
return {};
}
- RefsRequest Req;
+ llvm::DenseSet<SymbolID> IDs, Overrides;
const auto *IdentifierAtCursor =
syntax::spelledIdentifierTouching(*CurLoc, AST.getTokens());
Results.References.push_back(std::move(Result));
}
}
- Req.IDs.insert(MacroSID);
+ IDs.insert(MacroSID);
}
} else {
// Handle references to Decls.
if (auto ID = getSymbolID(D))
Targets.insert(ID);
- llvm::DenseSet<SymbolID> Overrides;
if (Index) {
RelationsRequest FindOverrides;
FindOverrides.Predicate = RelationKind::OverriddenBy;
ReferencesResult::Reference Result;
Result.Loc.range = Ref.range(SM);
Result.Loc.uri = URIMainFile;
- if (Ref.Role & static_cast<unsigned>(index::SymbolRole::Declaration))
- Result.Attributes |= ReferencesResult::Declaration;
- // clang-index doesn't report definitions as declarations, but they are.
- if (Ref.Role & static_cast<unsigned>(index::SymbolRole::Definition))
- Result.Attributes |=
- ReferencesResult::Definition | ReferencesResult::Declaration;
+ // Overrides are always considered references, not defs/decls.
+ if (!Overrides.contains(Ref.Target)) {
+ if (Ref.Role & static_cast<unsigned>(index::SymbolRole::Declaration))
+ Result.Attributes |= ReferencesResult::Declaration;
+ // clang-index doesn't report definitions as declarations, but they are.
+ if (Ref.Role & static_cast<unsigned>(index::SymbolRole::Definition))
+ Result.Attributes |=
+ ReferencesResult::Definition | ReferencesResult::Declaration;
+ }
Results.References.push_back(std::move(Result));
}
if (Index && Results.References.size() <= Limit) {
- Req.IDs = std::move(Overrides);
for (const Decl *D : Decls) {
// Not all symbols can be referenced from outside (e.g.
// function-locals).
if (D->getParentFunctionOrMethod())
continue;
if (auto ID = getSymbolID(D))
- Req.IDs.insert(ID);
+ IDs.insert(ID);
}
}
}
// Now query the index for references from other files.
- if (!Req.IDs.empty() && Index && Results.References.size() <= Limit) {
+ auto QueryIndex = [&](llvm::DenseSet<SymbolID> IDs, bool AllowAttributes) {
+ RefsRequest Req;
+ Req.IDs = std::move(IDs);
Req.Limit = Limit;
+ if (Req.IDs.empty() || !Index || Results.References.size() > Limit)
+ return;
Results.HasMore |= Index->refs(Req, [&](const Ref &R) {
// No need to continue process if we reach the limit.
if (Results.References.size() > Limit)
return;
ReferencesResult::Reference Result;
Result.Loc = std::move(*LSPLoc);
- if ((R.Kind & RefKind::Declaration) == RefKind::Declaration)
- Result.Attributes |= ReferencesResult::Declaration;
- // FIXME: our index should definitely store def | decl separately!
- if ((R.Kind & RefKind::Definition) == RefKind::Definition)
- Result.Attributes |=
- ReferencesResult::Declaration | ReferencesResult::Definition;
+ if (AllowAttributes) {
+ if ((R.Kind & RefKind::Declaration) == RefKind::Declaration)
+ Result.Attributes |= ReferencesResult::Declaration;
+ // FIXME: our index should definitely store def | decl separately!
+ if ((R.Kind & RefKind::Definition) == RefKind::Definition)
+ Result.Attributes |=
+ ReferencesResult::Declaration | ReferencesResult::Definition;
+ }
Results.References.push_back(std::move(Result));
});
- }
+ };
+ QueryIndex(std::move(IDs), /*AllowAttributes=*/true);
+ // FIXME: Currently we surface decls/defs/refs of derived methods.
+ // Maybe we'd prefer decls/defs of derived methods, and refs of base methods?
+ QueryIndex(std::move(Overrides), /*AllowAttributes=*/false);
if (Results.References.size() > Limit) {
Results.HasMore = true;
Results.References.resize(Limit);