forked from OSchip/llvm-project
1322 lines
46 KiB
C++
1322 lines
46 KiB
C++
//===--- XRefs.cpp -----------------------------------------------*- C++-*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
#include "XRefs.h"
|
|
#include "AST.h"
|
|
#include "CodeCompletionStrings.h"
|
|
#include "FindSymbols.h"
|
|
#include "FindTarget.h"
|
|
#include "FormattedString.h"
|
|
#include "Logger.h"
|
|
#include "ParsedAST.h"
|
|
#include "Protocol.h"
|
|
#include "SourceCode.h"
|
|
#include "URI.h"
|
|
#include "index/Index.h"
|
|
#include "index/Merge.h"
|
|
#include "index/Relation.h"
|
|
#include "index/SymbolCollector.h"
|
|
#include "index/SymbolLocation.h"
|
|
#include "clang/AST/ASTContext.h"
|
|
#include "clang/AST/Decl.h"
|
|
#include "clang/AST/DeclCXX.h"
|
|
#include "clang/AST/DeclTemplate.h"
|
|
#include "clang/AST/ExprCXX.h"
|
|
#include "clang/AST/PrettyPrinter.h"
|
|
#include "clang/AST/RecursiveASTVisitor.h"
|
|
#include "clang/AST/Type.h"
|
|
#include "clang/Basic/LLVM.h"
|
|
#include "clang/Basic/SourceLocation.h"
|
|
#include "clang/Basic/SourceManager.h"
|
|
#include "clang/Index/IndexDataConsumer.h"
|
|
#include "clang/Index/IndexSymbol.h"
|
|
#include "clang/Index/IndexingAction.h"
|
|
#include "clang/Index/IndexingOptions.h"
|
|
#include "clang/Index/USRGeneration.h"
|
|
#include "llvm/ADT/ArrayRef.h"
|
|
#include "llvm/ADT/None.h"
|
|
#include "llvm/ADT/STLExtras.h"
|
|
#include "llvm/ADT/StringExtras.h"
|
|
#include "llvm/ADT/StringRef.h"
|
|
#include "llvm/Support/Casting.h"
|
|
#include "llvm/Support/FormatVariadic.h"
|
|
#include "llvm/Support/Path.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
|
|
namespace clang {
|
|
namespace clangd {
|
|
namespace {
|
|
|
|
// Returns the single definition of the entity declared by D, if visible.
|
|
// In particular:
|
|
// - for non-redeclarable kinds (e.g. local vars), return D
|
|
// - for kinds that allow multiple definitions (e.g. namespaces), return nullptr
|
|
// Kinds of nodes that always return nullptr here will not have definitions
|
|
// reported by locateSymbolAt().
|
|
const Decl *getDefinition(const Decl *D) {
|
|
assert(D);
|
|
// Decl has one definition that we can find.
|
|
if (const auto *TD = dyn_cast<TagDecl>(D))
|
|
return TD->getDefinition();
|
|
if (const auto *VD = dyn_cast<VarDecl>(D))
|
|
return VD->getDefinition();
|
|
if (const auto *FD = dyn_cast<FunctionDecl>(D))
|
|
return FD->getDefinition();
|
|
// Only a single declaration is allowed.
|
|
if (isa<ValueDecl>(D) || isa<TemplateTypeParmDecl>(D) ||
|
|
isa<TemplateTemplateParmDecl>(D)) // except cases above
|
|
return D;
|
|
// Multiple definitions are allowed.
|
|
return nullptr; // except cases above
|
|
}
|
|
|
|
void logIfOverflow(const SymbolLocation &Loc) {
|
|
if (Loc.Start.hasOverflow() || Loc.End.hasOverflow())
|
|
log("Possible overflow in symbol location: {0}", Loc);
|
|
}
|
|
|
|
// Convert a SymbolLocation to LSP's Location.
|
|
// TUPath is used to resolve the path of URI.
|
|
// FIXME: figure out a good home for it, and share the implementation with
|
|
// FindSymbols.
|
|
llvm::Optional<Location> toLSPLocation(const SymbolLocation &Loc,
|
|
llvm::StringRef TUPath) {
|
|
if (!Loc)
|
|
return None;
|
|
auto Uri = URI::parse(Loc.FileURI);
|
|
if (!Uri) {
|
|
elog("Could not parse URI {0}: {1}", Loc.FileURI, Uri.takeError());
|
|
return None;
|
|
}
|
|
auto U = URIForFile::fromURI(*Uri, TUPath);
|
|
if (!U) {
|
|
elog("Could not resolve URI {0}: {1}", Loc.FileURI, U.takeError());
|
|
return None;
|
|
}
|
|
|
|
Location LSPLoc;
|
|
LSPLoc.uri = std::move(*U);
|
|
LSPLoc.range.start.line = Loc.Start.line();
|
|
LSPLoc.range.start.character = Loc.Start.column();
|
|
LSPLoc.range.end.line = Loc.End.line();
|
|
LSPLoc.range.end.character = Loc.End.column();
|
|
logIfOverflow(Loc);
|
|
return LSPLoc;
|
|
}
|
|
|
|
SymbolLocation toIndexLocation(const Location &Loc, std::string &URIStorage) {
|
|
SymbolLocation SymLoc;
|
|
URIStorage = Loc.uri.uri();
|
|
SymLoc.FileURI = URIStorage.c_str();
|
|
SymLoc.Start.setLine(Loc.range.start.line);
|
|
SymLoc.Start.setColumn(Loc.range.start.character);
|
|
SymLoc.End.setLine(Loc.range.end.line);
|
|
SymLoc.End.setColumn(Loc.range.end.character);
|
|
return SymLoc;
|
|
}
|
|
|
|
// Returns the preferred location between an AST location and an index location.
|
|
SymbolLocation getPreferredLocation(const Location &ASTLoc,
|
|
const SymbolLocation &IdxLoc,
|
|
std::string &Scratch) {
|
|
// Also use a dummy symbol for the index location so that other fields (e.g.
|
|
// definition) are not factored into the preferrence.
|
|
Symbol ASTSym, IdxSym;
|
|
ASTSym.ID = IdxSym.ID = SymbolID("dummy_id");
|
|
ASTSym.CanonicalDeclaration = toIndexLocation(ASTLoc, Scratch);
|
|
IdxSym.CanonicalDeclaration = IdxLoc;
|
|
auto Merged = mergeSymbol(ASTSym, IdxSym);
|
|
return Merged.CanonicalDeclaration;
|
|
}
|
|
|
|
/// Finds declarations locations that a given source location refers to.
|
|
class DeclarationFinder : public index::IndexDataConsumer {
|
|
llvm::DenseSet<const Decl *> Decls;
|
|
const SourceLocation &SearchedLocation;
|
|
|
|
public:
|
|
DeclarationFinder(const SourceLocation &SearchedLocation)
|
|
: SearchedLocation(SearchedLocation) {}
|
|
|
|
// The results are sorted by declaration location.
|
|
std::vector<const Decl *> getFoundDecls() const {
|
|
std::vector<const Decl *> Result;
|
|
for (const Decl *D : Decls)
|
|
Result.push_back(D);
|
|
|
|
llvm::sort(Result, [](const Decl *L, const Decl *R) {
|
|
return L->getBeginLoc() < R->getBeginLoc();
|
|
});
|
|
return Result;
|
|
}
|
|
|
|
bool
|
|
handleDeclOccurence(const Decl *D, index::SymbolRoleSet Roles,
|
|
llvm::ArrayRef<index::SymbolRelation> Relations,
|
|
SourceLocation Loc,
|
|
index::IndexDataConsumer::ASTNodeInfo ASTNode) override {
|
|
// Skip non-semantic references.
|
|
if (Roles & static_cast<unsigned>(index::SymbolRole::NameReference))
|
|
return true;
|
|
|
|
if (Loc == SearchedLocation) {
|
|
auto IsImplicitExpr = [](const Expr *E) {
|
|
if (!E)
|
|
return false;
|
|
// We assume that a constructor expression is implict (was inserted by
|
|
// clang) if it has an invalid paren/brace location, since such
|
|
// experssion is impossible to write down.
|
|
if (const auto *CtorExpr = dyn_cast<CXXConstructExpr>(E))
|
|
return CtorExpr->getParenOrBraceRange().isInvalid();
|
|
// Ignore implicit conversion-operator AST node.
|
|
if (const auto *ME = dyn_cast<MemberExpr>(E)) {
|
|
if (isa<CXXConversionDecl>(ME->getMemberDecl()))
|
|
return ME->getMemberLoc().isInvalid();
|
|
}
|
|
return isa<ImplicitCastExpr>(E);
|
|
};
|
|
|
|
if (IsImplicitExpr(ASTNode.OrigE))
|
|
return true;
|
|
// Find and add definition declarations (for GoToDefinition).
|
|
// We don't use parameter `D`, as Parameter `D` is the canonical
|
|
// declaration, which is the first declaration of a redeclarable
|
|
// declaration, and it could be a forward declaration.
|
|
if (const auto *Def = getDefinition(D)) {
|
|
Decls.insert(Def);
|
|
} else {
|
|
// Couldn't find a definition, fall back to use `D`.
|
|
Decls.insert(D);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
std::vector<const Decl *> getDeclAtPosition(ParsedAST &AST,
|
|
SourceLocation Pos) {
|
|
DeclarationFinder Finder(Pos);
|
|
index::IndexingOptions IndexOpts;
|
|
IndexOpts.SystemSymbolFilter =
|
|
index::IndexingOptions::SystemSymbolFilterKind::All;
|
|
IndexOpts.IndexFunctionLocals = true;
|
|
IndexOpts.IndexParametersInDeclarations = true;
|
|
IndexOpts.IndexTemplateParameters = true;
|
|
indexTopLevelDecls(AST.getASTContext(), AST.getPreprocessor(),
|
|
AST.getLocalTopLevelDecls(), Finder, IndexOpts);
|
|
|
|
return Finder.getFoundDecls();
|
|
}
|
|
|
|
llvm::Optional<Location> makeLocation(ASTContext &AST, SourceLocation TokLoc,
|
|
llvm::StringRef TUPath) {
|
|
const SourceManager &SourceMgr = AST.getSourceManager();
|
|
const FileEntry *F = SourceMgr.getFileEntryForID(SourceMgr.getFileID(TokLoc));
|
|
if (!F)
|
|
return None;
|
|
auto FilePath = getCanonicalPath(F, SourceMgr);
|
|
if (!FilePath) {
|
|
log("failed to get path!");
|
|
return None;
|
|
}
|
|
if (auto Range =
|
|
getTokenRange(AST.getSourceManager(), AST.getLangOpts(), TokLoc)) {
|
|
Location L;
|
|
L.uri = URIForFile::canonicalize(*FilePath, TUPath);
|
|
L.range = *Range;
|
|
return L;
|
|
}
|
|
return None;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
std::vector<LocatedSymbol> locateSymbolAt(ParsedAST &AST, Position Pos,
|
|
const SymbolIndex *Index) {
|
|
const auto &SM = AST.getSourceManager();
|
|
auto MainFilePath =
|
|
getCanonicalPath(SM.getFileEntryForID(SM.getMainFileID()), SM);
|
|
if (!MainFilePath) {
|
|
elog("Failed to get a path for the main file, so no references");
|
|
return {};
|
|
}
|
|
|
|
// Treat #included files as symbols, to enable go-to-definition on them.
|
|
for (auto &Inc : AST.getIncludeStructure().MainFileIncludes) {
|
|
if (!Inc.Resolved.empty() && Inc.R.start.line == Pos.line) {
|
|
LocatedSymbol File;
|
|
File.Name = llvm::sys::path::filename(Inc.Resolved);
|
|
File.PreferredDeclaration = {
|
|
URIForFile::canonicalize(Inc.Resolved, *MainFilePath), Range{}};
|
|
File.Definition = File.PreferredDeclaration;
|
|
// We're not going to find any further symbols on #include lines.
|
|
return {std::move(File)};
|
|
}
|
|
}
|
|
|
|
SourceLocation SourceLocationBeg =
|
|
SM.getMacroArgExpandedLocation(getBeginningOfIdentifier(
|
|
Pos, AST.getSourceManager(), AST.getASTContext().getLangOpts()));
|
|
|
|
// Macros are simple: there's no declaration/definition distinction.
|
|
// As a consequence, there's no need to look them up in the index either.
|
|
std::vector<LocatedSymbol> Result;
|
|
if (auto M = locateMacroAt(SourceLocationBeg, AST.getPreprocessor())) {
|
|
if (auto Loc = makeLocation(AST.getASTContext(),
|
|
M->Info->getDefinitionLoc(), *MainFilePath)) {
|
|
LocatedSymbol Macro;
|
|
Macro.Name = M->Name;
|
|
Macro.PreferredDeclaration = *Loc;
|
|
Macro.Definition = Loc;
|
|
Result.push_back(std::move(Macro));
|
|
}
|
|
}
|
|
|
|
// Decls are more complicated.
|
|
// The AST contains at least a declaration, maybe a definition.
|
|
// These are up-to-date, and so generally preferred over index results.
|
|
// We perform a single batch index lookup to find additional definitions.
|
|
|
|
// Results follow the order of Symbols.Decls.
|
|
// Keep track of SymbolID -> index mapping, to fill in index data later.
|
|
llvm::DenseMap<SymbolID, size_t> ResultIndex;
|
|
|
|
// Emit all symbol locations (declaration or definition) from AST.
|
|
for (const Decl *D : getDeclAtPosition(AST, SourceLocationBeg)) {
|
|
auto Loc =
|
|
makeLocation(AST.getASTContext(), spellingLocIfSpelled(findName(D), SM),
|
|
*MainFilePath);
|
|
if (!Loc)
|
|
continue;
|
|
|
|
Result.emplace_back();
|
|
if (auto *ND = dyn_cast<NamedDecl>(D))
|
|
Result.back().Name = printName(AST.getASTContext(), *ND);
|
|
Result.back().PreferredDeclaration = *Loc;
|
|
// DeclInfo.D is always a definition if possible, so this check works.
|
|
if (getDefinition(D) == D)
|
|
Result.back().Definition = *Loc;
|
|
|
|
// Record SymbolID for index lookup later.
|
|
if (auto ID = getSymbolID(D))
|
|
ResultIndex[*ID] = Result.size() - 1;
|
|
}
|
|
|
|
// Now query the index for all Symbol IDs we found in the AST.
|
|
if (Index && !ResultIndex.empty()) {
|
|
LookupRequest QueryRequest;
|
|
for (auto It : ResultIndex)
|
|
QueryRequest.IDs.insert(It.first);
|
|
std::string Scratch;
|
|
Index->lookup(QueryRequest, [&](const Symbol &Sym) {
|
|
auto &R = Result[ResultIndex.lookup(Sym.ID)];
|
|
|
|
if (R.Definition) { // from AST
|
|
// Special case: if the AST yielded a definition, then it may not be
|
|
// the right *declaration*. Prefer the one from the index.
|
|
if (auto Loc = toLSPLocation(Sym.CanonicalDeclaration, *MainFilePath))
|
|
R.PreferredDeclaration = *Loc;
|
|
|
|
// We might still prefer the definition from the index, e.g. for
|
|
// generated symbols.
|
|
if (auto Loc = toLSPLocation(
|
|
getPreferredLocation(*R.Definition, Sym.Definition, Scratch),
|
|
*MainFilePath))
|
|
R.Definition = *Loc;
|
|
} else {
|
|
R.Definition = toLSPLocation(Sym.Definition, *MainFilePath);
|
|
|
|
// Use merge logic to choose AST or index declaration.
|
|
if (auto Loc = toLSPLocation(
|
|
getPreferredLocation(R.PreferredDeclaration,
|
|
Sym.CanonicalDeclaration, Scratch),
|
|
*MainFilePath))
|
|
R.PreferredDeclaration = *Loc;
|
|
}
|
|
});
|
|
}
|
|
|
|
return Result;
|
|
}
|
|
|
|
namespace {
|
|
|
|
/// Collects references to symbols within the main file.
|
|
class ReferenceFinder : public index::IndexDataConsumer {
|
|
public:
|
|
struct Reference {
|
|
SourceLocation Loc;
|
|
index::SymbolRoleSet Role;
|
|
};
|
|
|
|
ReferenceFinder(ASTContext &AST, Preprocessor &PP,
|
|
const std::vector<const Decl *> &TargetDecls)
|
|
: AST(AST) {
|
|
for (const Decl *D : TargetDecls)
|
|
CanonicalTargets.insert(D->getCanonicalDecl());
|
|
}
|
|
|
|
std::vector<Reference> take() && {
|
|
llvm::sort(References, [](const Reference &L, const Reference &R) {
|
|
return std::tie(L.Loc, L.Role) < std::tie(R.Loc, R.Role);
|
|
});
|
|
// We sometimes see duplicates when parts of the AST get traversed twice.
|
|
References.erase(std::unique(References.begin(), References.end(),
|
|
[](const Reference &L, const Reference &R) {
|
|
return std::tie(L.Loc, L.Role) ==
|
|
std::tie(R.Loc, R.Role);
|
|
}),
|
|
References.end());
|
|
return std::move(References);
|
|
}
|
|
|
|
bool
|
|
handleDeclOccurence(const Decl *D, index::SymbolRoleSet Roles,
|
|
llvm::ArrayRef<index::SymbolRelation> Relations,
|
|
SourceLocation Loc,
|
|
index::IndexDataConsumer::ASTNodeInfo ASTNode) override {
|
|
assert(D->isCanonicalDecl() && "expect D to be a canonical declaration");
|
|
const SourceManager &SM = AST.getSourceManager();
|
|
Loc = SM.getFileLoc(Loc);
|
|
if (isInsideMainFile(Loc, SM) && CanonicalTargets.count(D))
|
|
References.push_back({Loc, Roles});
|
|
return true;
|
|
}
|
|
|
|
private:
|
|
llvm::SmallSet<const Decl *, 4> CanonicalTargets;
|
|
std::vector<Reference> References;
|
|
const ASTContext &AST;
|
|
};
|
|
|
|
std::vector<ReferenceFinder::Reference>
|
|
findRefs(const std::vector<const Decl *> &Decls, ParsedAST &AST) {
|
|
ReferenceFinder RefFinder(AST.getASTContext(), AST.getPreprocessor(), Decls);
|
|
index::IndexingOptions IndexOpts;
|
|
IndexOpts.SystemSymbolFilter =
|
|
index::IndexingOptions::SystemSymbolFilterKind::All;
|
|
IndexOpts.IndexFunctionLocals = true;
|
|
IndexOpts.IndexParametersInDeclarations = true;
|
|
IndexOpts.IndexTemplateParameters = true;
|
|
indexTopLevelDecls(AST.getASTContext(), AST.getPreprocessor(),
|
|
AST.getLocalTopLevelDecls(), RefFinder, IndexOpts);
|
|
return std::move(RefFinder).take();
|
|
}
|
|
|
|
} // namespace
|
|
|
|
std::vector<DocumentHighlight> findDocumentHighlights(ParsedAST &AST,
|
|
Position Pos) {
|
|
const SourceManager &SM = AST.getSourceManager();
|
|
// FIXME: show references to macro within file?
|
|
auto References =
|
|
findRefs(getDeclAtPosition(
|
|
AST, SM.getMacroArgExpandedLocation(getBeginningOfIdentifier(
|
|
Pos, SM, AST.getASTContext().getLangOpts()))),
|
|
AST);
|
|
|
|
// FIXME: we may get multiple DocumentHighlights with the same location and
|
|
// different kinds, deduplicate them.
|
|
std::vector<DocumentHighlight> Result;
|
|
for (const auto &Ref : References) {
|
|
if (auto Range =
|
|
getTokenRange(AST.getASTContext().getSourceManager(),
|
|
AST.getASTContext().getLangOpts(), Ref.Loc)) {
|
|
DocumentHighlight DH;
|
|
DH.range = *Range;
|
|
if (Ref.Role & index::SymbolRoleSet(index::SymbolRole::Write))
|
|
DH.kind = DocumentHighlightKind::Write;
|
|
else if (Ref.Role & index::SymbolRoleSet(index::SymbolRole::Read))
|
|
DH.kind = DocumentHighlightKind::Read;
|
|
else
|
|
DH.kind = DocumentHighlightKind::Text;
|
|
Result.push_back(std::move(DH));
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
|
|
static PrintingPolicy printingPolicyForDecls(PrintingPolicy Base) {
|
|
PrintingPolicy Policy(Base);
|
|
|
|
Policy.AnonymousTagLocations = false;
|
|
Policy.TerseOutput = true;
|
|
Policy.PolishForDeclaration = true;
|
|
Policy.ConstantsAsWritten = true;
|
|
Policy.SuppressTagKeyword = false;
|
|
|
|
return Policy;
|
|
}
|
|
|
|
/// Given a declaration \p D, return a human-readable string representing the
|
|
/// local scope in which it is declared, i.e. class(es) and method name. Returns
|
|
/// an empty string if it is not local.
|
|
static std::string getLocalScope(const Decl *D) {
|
|
std::vector<std::string> Scopes;
|
|
const DeclContext *DC = D->getDeclContext();
|
|
auto GetName = [](const Decl *D) {
|
|
const NamedDecl *ND = dyn_cast<NamedDecl>(D);
|
|
std::string Name = ND->getNameAsString();
|
|
if (!Name.empty())
|
|
return Name;
|
|
if (auto RD = dyn_cast<RecordDecl>(D))
|
|
return ("(anonymous " + RD->getKindName() + ")").str();
|
|
return std::string("");
|
|
};
|
|
while (DC) {
|
|
if (const TypeDecl *TD = dyn_cast<TypeDecl>(DC))
|
|
Scopes.push_back(GetName(TD));
|
|
else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(DC))
|
|
Scopes.push_back(FD->getNameAsString());
|
|
DC = DC->getParent();
|
|
}
|
|
|
|
return llvm::join(llvm::reverse(Scopes), "::");
|
|
}
|
|
|
|
/// Returns the human-readable representation for namespace containing the
|
|
/// declaration \p D. Returns empty if it is contained global namespace.
|
|
static std::string getNamespaceScope(const Decl *D) {
|
|
const DeclContext *DC = D->getDeclContext();
|
|
|
|
if (const TypeDecl *TD = dyn_cast<TypeDecl>(DC))
|
|
return getNamespaceScope(TD);
|
|
if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(DC))
|
|
return getNamespaceScope(FD);
|
|
if (const NamedDecl *ND = dyn_cast<NamedDecl>(DC))
|
|
return ND->getQualifiedNameAsString();
|
|
|
|
return "";
|
|
}
|
|
|
|
static std::string printDefinition(const Decl *D) {
|
|
std::string Definition;
|
|
llvm::raw_string_ostream OS(Definition);
|
|
PrintingPolicy Policy =
|
|
printingPolicyForDecls(D->getASTContext().getPrintingPolicy());
|
|
Policy.IncludeTagDefinition = false;
|
|
D->print(OS, Policy);
|
|
OS.flush();
|
|
return Definition;
|
|
}
|
|
|
|
static void printParams(llvm::raw_ostream &OS,
|
|
const std::vector<HoverInfo::Param> &Params) {
|
|
for (size_t I = 0, E = Params.size(); I != E; ++I) {
|
|
if (I)
|
|
OS << ", ";
|
|
OS << Params.at(I);
|
|
}
|
|
}
|
|
|
|
static std::vector<HoverInfo::Param>
|
|
fetchTemplateParameters(const TemplateParameterList *Params,
|
|
const PrintingPolicy &PP) {
|
|
assert(Params);
|
|
std::vector<HoverInfo::Param> TempParameters;
|
|
|
|
for (const Decl *Param : *Params) {
|
|
HoverInfo::Param P;
|
|
P.Type.emplace();
|
|
if (const auto TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
|
|
P.Type = TTP->wasDeclaredWithTypename() ? "typename" : "class";
|
|
if (TTP->isParameterPack())
|
|
*P.Type += "...";
|
|
|
|
if (!TTP->getName().empty())
|
|
P.Name = TTP->getNameAsString();
|
|
if (TTP->hasDefaultArgument())
|
|
P.Default = TTP->getDefaultArgument().getAsString(PP);
|
|
} else if (const auto NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
|
|
if (IdentifierInfo *II = NTTP->getIdentifier())
|
|
P.Name = II->getName().str();
|
|
|
|
llvm::raw_string_ostream Out(*P.Type);
|
|
NTTP->getType().print(Out, PP);
|
|
if (NTTP->isParameterPack())
|
|
Out << "...";
|
|
|
|
if (NTTP->hasDefaultArgument()) {
|
|
P.Default.emplace();
|
|
llvm::raw_string_ostream Out(*P.Default);
|
|
NTTP->getDefaultArgument()->printPretty(Out, nullptr, PP);
|
|
}
|
|
} else if (const auto TTPD = dyn_cast<TemplateTemplateParmDecl>(Param)) {
|
|
llvm::raw_string_ostream OS(*P.Type);
|
|
OS << "template <";
|
|
printParams(OS,
|
|
fetchTemplateParameters(TTPD->getTemplateParameters(), PP));
|
|
OS << "> class"; // FIXME: TemplateTemplateParameter doesn't store the
|
|
// info on whether this param was a "typename" or
|
|
// "class".
|
|
if (!TTPD->getName().empty())
|
|
P.Name = TTPD->getNameAsString();
|
|
if (TTPD->hasDefaultArgument()) {
|
|
P.Default.emplace();
|
|
llvm::raw_string_ostream Out(*P.Default);
|
|
TTPD->getDefaultArgument().getArgument().print(PP, Out);
|
|
}
|
|
}
|
|
TempParameters.push_back(std::move(P));
|
|
}
|
|
|
|
return TempParameters;
|
|
}
|
|
|
|
static const FunctionDecl *getUnderlyingFunction(const Decl *D) {
|
|
// Extract lambda from variables.
|
|
if (const VarDecl *VD = llvm::dyn_cast<VarDecl>(D)) {
|
|
auto QT = VD->getType();
|
|
if (!QT.isNull()) {
|
|
while (!QT->getPointeeType().isNull())
|
|
QT = QT->getPointeeType();
|
|
|
|
if (const auto *CD = QT->getAsCXXRecordDecl())
|
|
return CD->getLambdaCallOperator();
|
|
}
|
|
}
|
|
|
|
// Non-lambda functions.
|
|
return D->getAsFunction();
|
|
}
|
|
|
|
// Look up information about D from the index, and add it to Hover.
|
|
static void enhanceFromIndex(HoverInfo &Hover, const Decl *D,
|
|
const SymbolIndex *Index) {
|
|
if (!Index || !llvm::isa<NamedDecl>(D))
|
|
return;
|
|
const NamedDecl &ND = *cast<NamedDecl>(D);
|
|
// We only add documentation, so don't bother if we already have some.
|
|
if (!Hover.Documentation.empty())
|
|
return;
|
|
// Skip querying for non-indexable symbols, there's no point.
|
|
// We're searching for symbols that might be indexed outside this main file.
|
|
if (!SymbolCollector::shouldCollectSymbol(ND, ND.getASTContext(),
|
|
SymbolCollector::Options(),
|
|
/*IsMainFileOnly=*/false))
|
|
return;
|
|
auto ID = getSymbolID(&ND);
|
|
if (!ID)
|
|
return;
|
|
LookupRequest Req;
|
|
Req.IDs.insert(*ID);
|
|
Index->lookup(
|
|
Req, [&](const Symbol &S) { Hover.Documentation = S.Documentation; });
|
|
}
|
|
|
|
/// Generate a \p Hover object given the declaration \p D.
|
|
static HoverInfo getHoverContents(const Decl *D, const SymbolIndex *Index) {
|
|
HoverInfo HI;
|
|
const ASTContext &Ctx = D->getASTContext();
|
|
|
|
HI.NamespaceScope = getNamespaceScope(D);
|
|
if (!HI.NamespaceScope->empty())
|
|
HI.NamespaceScope->append("::");
|
|
HI.LocalScope = getLocalScope(D);
|
|
if (!HI.LocalScope.empty())
|
|
HI.LocalScope.append("::");
|
|
|
|
PrintingPolicy Policy = printingPolicyForDecls(Ctx.getPrintingPolicy());
|
|
if (const NamedDecl *ND = llvm::dyn_cast<NamedDecl>(D)) {
|
|
HI.Documentation = getDeclComment(Ctx, *ND);
|
|
HI.Name = printName(Ctx, *ND);
|
|
}
|
|
|
|
HI.Kind = indexSymbolKindToSymbolKind(index::getSymbolInfo(D).Kind);
|
|
|
|
// Fill in template params.
|
|
if (const TemplateDecl *TD = D->getDescribedTemplate()) {
|
|
HI.TemplateParameters =
|
|
fetchTemplateParameters(TD->getTemplateParameters(), Policy);
|
|
D = TD;
|
|
} else if (const FunctionDecl *FD = D->getAsFunction()) {
|
|
if (const auto FTD = FD->getDescribedTemplate()) {
|
|
HI.TemplateParameters =
|
|
fetchTemplateParameters(FTD->getTemplateParameters(), Policy);
|
|
D = FTD;
|
|
}
|
|
}
|
|
|
|
// Fill in types and params.
|
|
if (const FunctionDecl *FD = getUnderlyingFunction(D)) {
|
|
HI.ReturnType.emplace();
|
|
{
|
|
llvm::raw_string_ostream OS(*HI.ReturnType);
|
|
FD->getReturnType().print(OS, Policy);
|
|
}
|
|
|
|
HI.Parameters.emplace();
|
|
for (const ParmVarDecl *PVD : FD->parameters()) {
|
|
HI.Parameters->emplace_back();
|
|
auto &P = HI.Parameters->back();
|
|
if (!PVD->getType().isNull()) {
|
|
P.Type.emplace();
|
|
llvm::raw_string_ostream OS(*P.Type);
|
|
PVD->getType().print(OS, Policy);
|
|
} else {
|
|
std::string Param;
|
|
llvm::raw_string_ostream OS(Param);
|
|
PVD->dump(OS);
|
|
OS.flush();
|
|
elog("Got param with null type: {0}", Param);
|
|
}
|
|
if (!PVD->getName().empty())
|
|
P.Name = PVD->getNameAsString();
|
|
if (PVD->hasDefaultArg()) {
|
|
P.Default.emplace();
|
|
llvm::raw_string_ostream Out(*P.Default);
|
|
PVD->getDefaultArg()->printPretty(Out, nullptr, Policy);
|
|
}
|
|
}
|
|
|
|
HI.Type.emplace();
|
|
llvm::raw_string_ostream TypeOS(*HI.Type);
|
|
// Lambdas
|
|
if (const VarDecl *VD = llvm::dyn_cast<VarDecl>(D))
|
|
VD->getType().getDesugaredType(D->getASTContext()).print(TypeOS, Policy);
|
|
// Functions
|
|
else
|
|
FD->getType().print(TypeOS, Policy);
|
|
// FIXME: handle variadics.
|
|
} else if (const auto *VD = dyn_cast<ValueDecl>(D)) {
|
|
HI.Type.emplace();
|
|
llvm::raw_string_ostream OS(*HI.Type);
|
|
VD->getType().print(OS, Policy);
|
|
}
|
|
|
|
// Fill in value with evaluated initializer if possible.
|
|
// FIXME(kadircet): Also set Value field for expressions like "sizeof" and
|
|
// function calls.
|
|
if (const auto *Var = dyn_cast<VarDecl>(D)) {
|
|
if (const Expr *Init = Var->getInit()) {
|
|
Expr::EvalResult Result;
|
|
if (!Init->isValueDependent() && Init->EvaluateAsRValue(Result, Ctx)) {
|
|
HI.Value.emplace();
|
|
llvm::raw_string_ostream ValueOS(*HI.Value);
|
|
Result.Val.printPretty(ValueOS, const_cast<ASTContext &>(Ctx),
|
|
Init->getType());
|
|
}
|
|
}
|
|
}
|
|
|
|
HI.Definition = printDefinition(D);
|
|
enhanceFromIndex(HI, D, Index);
|
|
return HI;
|
|
}
|
|
|
|
/// Generate a \p Hover object given the type \p T.
|
|
static HoverInfo getHoverContents(QualType T, const Decl *D, ASTContext &ASTCtx,
|
|
const SymbolIndex *Index) {
|
|
HoverInfo HI;
|
|
llvm::raw_string_ostream OS(HI.Name);
|
|
PrintingPolicy Policy = printingPolicyForDecls(ASTCtx.getPrintingPolicy());
|
|
T.print(OS, Policy);
|
|
OS.flush();
|
|
|
|
if (D) {
|
|
HI.Kind = indexSymbolKindToSymbolKind(index::getSymbolInfo(D).Kind);
|
|
enhanceFromIndex(HI, D, Index);
|
|
}
|
|
return HI;
|
|
}
|
|
|
|
/// Generate a \p Hover object given the macro \p MacroDecl.
|
|
static HoverInfo getHoverContents(const DefinedMacro &Macro, ParsedAST &AST) {
|
|
HoverInfo HI;
|
|
SourceManager &SM = AST.getSourceManager();
|
|
HI.Name = Macro.Name;
|
|
HI.Kind = indexSymbolKindToSymbolKind(
|
|
index::getSymbolInfoForMacro(*Macro.Info).Kind);
|
|
// FIXME: Populate documentation
|
|
// FIXME: Pupulate parameters
|
|
|
|
// Try to get the full definition, not just the name
|
|
SourceLocation StartLoc = Macro.Info->getDefinitionLoc();
|
|
SourceLocation EndLoc = Macro.Info->getDefinitionEndLoc();
|
|
if (EndLoc.isValid()) {
|
|
EndLoc = Lexer::getLocForEndOfToken(EndLoc, 0, SM,
|
|
AST.getASTContext().getLangOpts());
|
|
bool Invalid;
|
|
StringRef Buffer = SM.getBufferData(SM.getFileID(StartLoc), &Invalid);
|
|
if (!Invalid) {
|
|
unsigned StartOffset = SM.getFileOffset(StartLoc);
|
|
unsigned EndOffset = SM.getFileOffset(EndLoc);
|
|
if (EndOffset <= Buffer.size() && StartOffset < EndOffset)
|
|
HI.Definition =
|
|
("#define " + Buffer.substr(StartOffset, EndOffset - StartOffset))
|
|
.str();
|
|
}
|
|
}
|
|
return HI;
|
|
}
|
|
|
|
namespace {
|
|
/// Computes the deduced type at a given location by visiting the relevant
|
|
/// nodes. We use this to display the actual type when hovering over an "auto"
|
|
/// keyword or "decltype()" expression.
|
|
/// FIXME: This could have been a lot simpler by visiting AutoTypeLocs but it
|
|
/// seems that the AutoTypeLocs that can be visited along with their AutoType do
|
|
/// not have the deduced type set. Instead, we have to go to the appropriate
|
|
/// DeclaratorDecl/FunctionDecl and work our back to the AutoType that does have
|
|
/// a deduced type set. The AST should be improved to simplify this scenario.
|
|
class DeducedTypeVisitor : public RecursiveASTVisitor<DeducedTypeVisitor> {
|
|
SourceLocation SearchedLocation;
|
|
|
|
public:
|
|
DeducedTypeVisitor(SourceLocation SearchedLocation)
|
|
: SearchedLocation(SearchedLocation) {}
|
|
|
|
// Handle auto initializers:
|
|
//- auto i = 1;
|
|
//- decltype(auto) i = 1;
|
|
//- auto& i = 1;
|
|
//- auto* i = &a;
|
|
bool VisitDeclaratorDecl(DeclaratorDecl *D) {
|
|
if (!D->getTypeSourceInfo() ||
|
|
D->getTypeSourceInfo()->getTypeLoc().getBeginLoc() != SearchedLocation)
|
|
return true;
|
|
|
|
if (auto *AT = D->getType()->getContainedAutoType()) {
|
|
if (!AT->getDeducedType().isNull()) {
|
|
DeducedType = AT->getDeducedType();
|
|
this->D = D;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Handle auto return types:
|
|
//- auto foo() {}
|
|
//- auto& foo() {}
|
|
//- auto foo() -> int {}
|
|
//- auto foo() -> decltype(1+1) {}
|
|
//- operator auto() const { return 10; }
|
|
bool VisitFunctionDecl(FunctionDecl *D) {
|
|
if (!D->getTypeSourceInfo())
|
|
return true;
|
|
// Loc of auto in return type (c++14).
|
|
auto CurLoc = D->getReturnTypeSourceRange().getBegin();
|
|
// Loc of "auto" in operator auto()
|
|
if (CurLoc.isInvalid() && dyn_cast<CXXConversionDecl>(D))
|
|
CurLoc = D->getTypeSourceInfo()->getTypeLoc().getBeginLoc();
|
|
// Loc of "auto" in function with traling return type (c++11).
|
|
if (CurLoc.isInvalid())
|
|
CurLoc = D->getSourceRange().getBegin();
|
|
if (CurLoc != SearchedLocation)
|
|
return true;
|
|
|
|
const AutoType *AT = D->getReturnType()->getContainedAutoType();
|
|
if (AT && !AT->getDeducedType().isNull()) {
|
|
DeducedType = AT->getDeducedType();
|
|
this->D = D;
|
|
} else if (auto DT = dyn_cast<DecltypeType>(D->getReturnType())) {
|
|
// auto in a trailing return type just points to a DecltypeType and
|
|
// getContainedAutoType does not unwrap it.
|
|
if (!DT->getUnderlyingType().isNull()) {
|
|
DeducedType = DT->getUnderlyingType();
|
|
this->D = D;
|
|
}
|
|
} else if (!D->getReturnType().isNull()) {
|
|
DeducedType = D->getReturnType();
|
|
this->D = D;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Handle non-auto decltype, e.g.:
|
|
// - auto foo() -> decltype(expr) {}
|
|
// - decltype(expr);
|
|
bool VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
|
|
if (TL.getBeginLoc() != SearchedLocation)
|
|
return true;
|
|
|
|
// A DecltypeType's underlying type can be another DecltypeType! E.g.
|
|
// int I = 0;
|
|
// decltype(I) J = I;
|
|
// decltype(J) K = J;
|
|
const DecltypeType *DT = dyn_cast<DecltypeType>(TL.getTypePtr());
|
|
while (DT && !DT->getUnderlyingType().isNull()) {
|
|
DeducedType = DT->getUnderlyingType();
|
|
D = DT->getAsTagDecl();
|
|
DT = dyn_cast<DecltypeType>(DeducedType.getTypePtr());
|
|
}
|
|
return true;
|
|
}
|
|
|
|
QualType DeducedType;
|
|
const Decl *D = nullptr;
|
|
};
|
|
} // namespace
|
|
|
|
/// Retrieves the deduced type at a given location (auto, decltype).
|
|
/// SourceLocationBeg must point to the first character of the token
|
|
llvm::Optional<QualType> getDeducedType(ParsedAST &AST,
|
|
SourceLocation SourceLocationBeg) {
|
|
Token Tok;
|
|
auto &ASTCtx = AST.getASTContext();
|
|
// Only try to find a deduced type if the token is auto or decltype.
|
|
if (!SourceLocationBeg.isValid() ||
|
|
Lexer::getRawToken(SourceLocationBeg, Tok, ASTCtx.getSourceManager(),
|
|
ASTCtx.getLangOpts(), false) ||
|
|
!Tok.is(tok::raw_identifier)) {
|
|
return {};
|
|
}
|
|
AST.getPreprocessor().LookUpIdentifierInfo(Tok);
|
|
if (!(Tok.is(tok::kw_auto) || Tok.is(tok::kw_decltype)))
|
|
return {};
|
|
|
|
DeducedTypeVisitor V(SourceLocationBeg);
|
|
V.TraverseAST(AST.getASTContext());
|
|
return V.DeducedType;
|
|
}
|
|
|
|
/// Retrieves the deduced type at a given location (auto, decltype).
|
|
bool hasDeducedType(ParsedAST &AST, SourceLocation SourceLocationBeg) {
|
|
return (bool)getDeducedType(AST, SourceLocationBeg);
|
|
}
|
|
|
|
llvm::Optional<HoverInfo> getHover(ParsedAST &AST, Position Pos,
|
|
format::FormatStyle Style,
|
|
const SymbolIndex *Index) {
|
|
const SourceManager &SM = AST.getSourceManager();
|
|
llvm::Optional<HoverInfo> HI;
|
|
SourceLocation SourceLocationBeg = SM.getMacroArgExpandedLocation(
|
|
getBeginningOfIdentifier(Pos, SM, AST.getASTContext().getLangOpts()));
|
|
|
|
if (auto M = locateMacroAt(SourceLocationBeg, AST.getPreprocessor())) {
|
|
HI = getHoverContents(*M, AST);
|
|
} else {
|
|
auto Decls = getDeclAtPosition(AST, SourceLocationBeg);
|
|
if (!Decls.empty())
|
|
HI = getHoverContents(Decls.front(), Index);
|
|
}
|
|
if (!HI && hasDeducedType(AST, SourceLocationBeg)) {
|
|
DeducedTypeVisitor V(SourceLocationBeg);
|
|
V.TraverseAST(AST.getASTContext());
|
|
if (!V.DeducedType.isNull())
|
|
HI = getHoverContents(V.DeducedType, V.D, AST.getASTContext(), Index);
|
|
}
|
|
if (!HI)
|
|
return llvm::None;
|
|
|
|
auto Replacements = format::reformat(
|
|
Style, HI->Definition, tooling::Range(0, HI->Definition.size()));
|
|
if (auto Formatted =
|
|
tooling::applyAllReplacements(HI->Definition, Replacements))
|
|
HI->Definition = *Formatted;
|
|
|
|
HI->SymRange =
|
|
getTokenRange(AST.getASTContext().getSourceManager(),
|
|
AST.getASTContext().getLangOpts(), SourceLocationBeg);
|
|
return HI;
|
|
}
|
|
|
|
std::vector<Location> findReferences(ParsedAST &AST, Position Pos,
|
|
uint32_t Limit, const SymbolIndex *Index) {
|
|
if (!Limit)
|
|
Limit = std::numeric_limits<uint32_t>::max();
|
|
std::vector<Location> Results;
|
|
const SourceManager &SM = AST.getSourceManager();
|
|
auto MainFilePath =
|
|
getCanonicalPath(SM.getFileEntryForID(SM.getMainFileID()), SM);
|
|
if (!MainFilePath) {
|
|
elog("Failed to get a path for the main file, so no references");
|
|
return Results;
|
|
}
|
|
auto Loc = SM.getMacroArgExpandedLocation(
|
|
getBeginningOfIdentifier(Pos, SM, AST.getASTContext().getLangOpts()));
|
|
// TODO: should we handle macros, too?
|
|
auto Decls = getDeclAtPosition(AST, Loc);
|
|
|
|
// We traverse the AST to find references in the main file.
|
|
auto MainFileRefs = findRefs(Decls, AST);
|
|
// We may get multiple refs with the same location and different Roles, as
|
|
// cross-reference is only interested in locations, we deduplicate them
|
|
// by the location to avoid emitting duplicated locations.
|
|
MainFileRefs.erase(std::unique(MainFileRefs.begin(), MainFileRefs.end(),
|
|
[](const ReferenceFinder::Reference &L,
|
|
const ReferenceFinder::Reference &R) {
|
|
return L.Loc == R.Loc;
|
|
}),
|
|
MainFileRefs.end());
|
|
for (const auto &Ref : MainFileRefs) {
|
|
if (auto Range =
|
|
getTokenRange(AST.getASTContext().getSourceManager(),
|
|
AST.getASTContext().getLangOpts(), Ref.Loc)) {
|
|
Location Result;
|
|
Result.range = *Range;
|
|
Result.uri = URIForFile::canonicalize(*MainFilePath, *MainFilePath);
|
|
Results.push_back(std::move(Result));
|
|
}
|
|
}
|
|
|
|
// Now query the index for references from other files.
|
|
if (Index && Results.size() < Limit) {
|
|
RefsRequest Req;
|
|
Req.Limit = Limit;
|
|
|
|
for (const Decl *D : Decls) {
|
|
// Not all symbols can be referenced from outside (e.g. function-locals).
|
|
// TODO: we could skip TU-scoped symbols here (e.g. static functions) if
|
|
// we know this file isn't a header. The details might be tricky.
|
|
if (D->getParentFunctionOrMethod())
|
|
continue;
|
|
if (auto ID = getSymbolID(D))
|
|
Req.IDs.insert(*ID);
|
|
}
|
|
if (Req.IDs.empty())
|
|
return Results;
|
|
Index->refs(Req, [&](const Ref &R) {
|
|
auto LSPLoc = toLSPLocation(R.Location, *MainFilePath);
|
|
// Avoid indexed results for the main file - the AST is authoritative.
|
|
if (LSPLoc && LSPLoc->uri.file() != *MainFilePath)
|
|
Results.push_back(std::move(*LSPLoc));
|
|
});
|
|
}
|
|
if (Results.size() > Limit)
|
|
Results.resize(Limit);
|
|
return Results;
|
|
}
|
|
|
|
std::vector<SymbolDetails> getSymbolInfo(ParsedAST &AST, Position Pos) {
|
|
const SourceManager &SM = AST.getSourceManager();
|
|
auto Loc = SM.getMacroArgExpandedLocation(
|
|
getBeginningOfIdentifier(Pos, SM, AST.getASTContext().getLangOpts()));
|
|
|
|
std::vector<SymbolDetails> Results;
|
|
|
|
for (const Decl *D : getDeclAtPosition(AST, Loc)) {
|
|
SymbolDetails NewSymbol;
|
|
if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
|
|
std::string QName = printQualifiedName(*ND);
|
|
std::tie(NewSymbol.containerName, NewSymbol.name) =
|
|
splitQualifiedName(QName);
|
|
|
|
if (NewSymbol.containerName.empty()) {
|
|
if (const auto *ParentND =
|
|
dyn_cast_or_null<NamedDecl>(ND->getDeclContext()))
|
|
NewSymbol.containerName = printQualifiedName(*ParentND);
|
|
}
|
|
}
|
|
llvm::SmallString<32> USR;
|
|
if (!index::generateUSRForDecl(D, USR)) {
|
|
NewSymbol.USR = USR.str();
|
|
NewSymbol.ID = SymbolID(NewSymbol.USR);
|
|
}
|
|
Results.push_back(std::move(NewSymbol));
|
|
}
|
|
|
|
if (auto M = locateMacroAt(Loc, AST.getPreprocessor())) {
|
|
SymbolDetails NewMacro;
|
|
NewMacro.name = M->Name;
|
|
llvm::SmallString<32> USR;
|
|
if (!index::generateUSRForMacro(NewMacro.name, M->Info->getDefinitionLoc(),
|
|
SM, USR)) {
|
|
NewMacro.USR = USR.str();
|
|
NewMacro.ID = SymbolID(NewMacro.USR);
|
|
}
|
|
Results.push_back(std::move(NewMacro));
|
|
}
|
|
|
|
return Results;
|
|
}
|
|
|
|
llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const LocatedSymbol &S) {
|
|
OS << S.Name << ": " << S.PreferredDeclaration;
|
|
if (S.Definition)
|
|
OS << " def=" << *S.Definition;
|
|
return OS;
|
|
}
|
|
|
|
// FIXME(nridge): Reduce duplication between this function and declToSym().
|
|
static llvm::Optional<TypeHierarchyItem>
|
|
declToTypeHierarchyItem(ASTContext &Ctx, const NamedDecl &ND) {
|
|
auto &SM = Ctx.getSourceManager();
|
|
|
|
SourceLocation NameLoc =
|
|
spellingLocIfSpelled(findName(&ND), Ctx.getSourceManager());
|
|
// getFileLoc is a good choice for us, but we also need to make sure
|
|
// sourceLocToPosition won't switch files, so we call getSpellingLoc on top of
|
|
// that to make sure it does not switch files.
|
|
// FIXME: sourceLocToPosition should not switch files!
|
|
SourceLocation BeginLoc = SM.getSpellingLoc(SM.getFileLoc(ND.getBeginLoc()));
|
|
SourceLocation EndLoc = SM.getSpellingLoc(SM.getFileLoc(ND.getEndLoc()));
|
|
if (NameLoc.isInvalid() || BeginLoc.isInvalid() || EndLoc.isInvalid())
|
|
return llvm::None;
|
|
|
|
Position NameBegin = sourceLocToPosition(SM, NameLoc);
|
|
Position NameEnd = sourceLocToPosition(
|
|
SM, Lexer::getLocForEndOfToken(NameLoc, 0, SM, Ctx.getLangOpts()));
|
|
|
|
index::SymbolInfo SymInfo = index::getSymbolInfo(&ND);
|
|
// FIXME: this is not classifying constructors, destructors and operators
|
|
// correctly (they're all "methods").
|
|
SymbolKind SK = indexSymbolKindToSymbolKind(SymInfo.Kind);
|
|
|
|
TypeHierarchyItem THI;
|
|
THI.name = printName(Ctx, ND);
|
|
THI.kind = SK;
|
|
THI.deprecated = ND.isDeprecated();
|
|
THI.range =
|
|
Range{sourceLocToPosition(SM, BeginLoc), sourceLocToPosition(SM, EndLoc)};
|
|
THI.selectionRange = Range{NameBegin, NameEnd};
|
|
if (!THI.range.contains(THI.selectionRange)) {
|
|
// 'selectionRange' must be contained in 'range', so in cases where clang
|
|
// reports unrelated ranges we need to reconcile somehow.
|
|
THI.range = THI.selectionRange;
|
|
}
|
|
|
|
auto FilePath =
|
|
getCanonicalPath(SM.getFileEntryForID(SM.getFileID(BeginLoc)), SM);
|
|
auto TUPath = getCanonicalPath(SM.getFileEntryForID(SM.getMainFileID()), SM);
|
|
if (!FilePath || !TUPath)
|
|
return llvm::None; // Not useful without a uri.
|
|
THI.uri = URIForFile::canonicalize(*FilePath, *TUPath);
|
|
|
|
return THI;
|
|
}
|
|
|
|
static Optional<TypeHierarchyItem>
|
|
symbolToTypeHierarchyItem(const Symbol &S, const SymbolIndex *Index,
|
|
PathRef TUPath) {
|
|
auto Loc = symbolToLocation(S, TUPath);
|
|
if (!Loc) {
|
|
log("Type hierarchy: {0}", Loc.takeError());
|
|
return llvm::None;
|
|
}
|
|
TypeHierarchyItem THI;
|
|
THI.name = S.Name;
|
|
THI.kind = indexSymbolKindToSymbolKind(S.SymInfo.Kind);
|
|
THI.deprecated = (S.Flags & Symbol::Deprecated);
|
|
THI.selectionRange = Loc->range;
|
|
// FIXME: Populate 'range' correctly
|
|
// (https://github.com/clangd/clangd/issues/59).
|
|
THI.range = THI.selectionRange;
|
|
THI.uri = Loc->uri;
|
|
// Store the SymbolID in the 'data' field. The client will
|
|
// send this back in typeHierarchy/resolve, allowing us to
|
|
// continue resolving additional levels of the type hierarchy.
|
|
THI.data = S.ID.str();
|
|
|
|
return std::move(THI);
|
|
}
|
|
|
|
static void fillSubTypes(const SymbolID &ID,
|
|
std::vector<TypeHierarchyItem> &SubTypes,
|
|
const SymbolIndex *Index, int Levels, PathRef TUPath) {
|
|
RelationsRequest Req;
|
|
Req.Subjects.insert(ID);
|
|
Req.Predicate = RelationKind::BaseOf;
|
|
Index->relations(Req, [&](const SymbolID &Subject, const Symbol &Object) {
|
|
if (Optional<TypeHierarchyItem> ChildSym =
|
|
symbolToTypeHierarchyItem(Object, Index, TUPath)) {
|
|
if (Levels > 1) {
|
|
ChildSym->children.emplace();
|
|
fillSubTypes(Object.ID, *ChildSym->children, Index, Levels - 1, TUPath);
|
|
}
|
|
SubTypes.emplace_back(std::move(*ChildSym));
|
|
}
|
|
});
|
|
}
|
|
|
|
using RecursionProtectionSet = llvm::SmallSet<const CXXRecordDecl *, 4>;
|
|
|
|
static void fillSuperTypes(const CXXRecordDecl &CXXRD, ASTContext &ASTCtx,
|
|
std::vector<TypeHierarchyItem> &SuperTypes,
|
|
RecursionProtectionSet &RPSet) {
|
|
// typeParents() will replace dependent template specializations
|
|
// with their class template, so to avoid infinite recursion for
|
|
// certain types of hierarchies, keep the templates encountered
|
|
// along the parent chain in a set, and stop the recursion if one
|
|
// starts to repeat.
|
|
auto *Pattern = CXXRD.getDescribedTemplate() ? &CXXRD : nullptr;
|
|
if (Pattern) {
|
|
if (!RPSet.insert(Pattern).second) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
for (const CXXRecordDecl *ParentDecl : typeParents(&CXXRD)) {
|
|
if (Optional<TypeHierarchyItem> ParentSym =
|
|
declToTypeHierarchyItem(ASTCtx, *ParentDecl)) {
|
|
ParentSym->parents.emplace();
|
|
fillSuperTypes(*ParentDecl, ASTCtx, *ParentSym->parents, RPSet);
|
|
SuperTypes.emplace_back(std::move(*ParentSym));
|
|
}
|
|
}
|
|
|
|
if (Pattern) {
|
|
RPSet.erase(Pattern);
|
|
}
|
|
}
|
|
|
|
const CXXRecordDecl *findRecordTypeAt(ParsedAST &AST, Position Pos) {
|
|
const SourceManager &SM = AST.getSourceManager();
|
|
SourceLocation SourceLocationBeg = SM.getMacroArgExpandedLocation(
|
|
getBeginningOfIdentifier(Pos, SM, AST.getASTContext().getLangOpts()));
|
|
auto Decls = getDeclAtPosition(AST, SourceLocationBeg);
|
|
if (Decls.empty())
|
|
return nullptr;
|
|
|
|
const Decl *D = Decls[0];
|
|
|
|
if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
|
|
// If this is a variable, use the type of the variable.
|
|
return VD->getType().getTypePtr()->getAsCXXRecordDecl();
|
|
}
|
|
|
|
if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
|
|
// If this is a method, use the type of the class.
|
|
return Method->getParent();
|
|
}
|
|
|
|
// We don't handle FieldDecl because it's not clear what behaviour
|
|
// the user would expect: the enclosing class type (as with a
|
|
// method), or the field's type (as with a variable).
|
|
|
|
return dyn_cast<CXXRecordDecl>(D);
|
|
}
|
|
|
|
std::vector<const CXXRecordDecl *> typeParents(const CXXRecordDecl *CXXRD) {
|
|
std::vector<const CXXRecordDecl *> Result;
|
|
|
|
for (auto Base : CXXRD->bases()) {
|
|
const CXXRecordDecl *ParentDecl = nullptr;
|
|
|
|
const Type *Type = Base.getType().getTypePtr();
|
|
if (const RecordType *RT = Type->getAs<RecordType>()) {
|
|
ParentDecl = RT->getAsCXXRecordDecl();
|
|
}
|
|
|
|
if (!ParentDecl) {
|
|
// Handle a dependent base such as "Base<T>" by using the primary
|
|
// template.
|
|
if (const TemplateSpecializationType *TS =
|
|
Type->getAs<TemplateSpecializationType>()) {
|
|
TemplateName TN = TS->getTemplateName();
|
|
if (TemplateDecl *TD = TN.getAsTemplateDecl()) {
|
|
ParentDecl = dyn_cast<CXXRecordDecl>(TD->getTemplatedDecl());
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ParentDecl)
|
|
Result.push_back(ParentDecl);
|
|
}
|
|
|
|
return Result;
|
|
}
|
|
|
|
llvm::Optional<TypeHierarchyItem>
|
|
getTypeHierarchy(ParsedAST &AST, Position Pos, int ResolveLevels,
|
|
TypeHierarchyDirection Direction, const SymbolIndex *Index,
|
|
PathRef TUPath) {
|
|
const CXXRecordDecl *CXXRD = findRecordTypeAt(AST, Pos);
|
|
if (!CXXRD)
|
|
return llvm::None;
|
|
|
|
Optional<TypeHierarchyItem> Result =
|
|
declToTypeHierarchyItem(AST.getASTContext(), *CXXRD);
|
|
if (!Result)
|
|
return Result;
|
|
|
|
if (Direction == TypeHierarchyDirection::Parents ||
|
|
Direction == TypeHierarchyDirection::Both) {
|
|
Result->parents.emplace();
|
|
|
|
RecursionProtectionSet RPSet;
|
|
fillSuperTypes(*CXXRD, AST.getASTContext(), *Result->parents, RPSet);
|
|
}
|
|
|
|
if ((Direction == TypeHierarchyDirection::Children ||
|
|
Direction == TypeHierarchyDirection::Both) &&
|
|
ResolveLevels > 0) {
|
|
Result->children.emplace();
|
|
|
|
if (Index) {
|
|
if (Optional<SymbolID> ID = getSymbolID(CXXRD))
|
|
fillSubTypes(*ID, *Result->children, Index, ResolveLevels, TUPath);
|
|
}
|
|
}
|
|
|
|
return Result;
|
|
}
|
|
|
|
void resolveTypeHierarchy(TypeHierarchyItem &Item, int ResolveLevels,
|
|
TypeHierarchyDirection Direction,
|
|
const SymbolIndex *Index) {
|
|
// We only support typeHierarchy/resolve for children, because for parents
|
|
// we ignore ResolveLevels and return all levels of parents eagerly.
|
|
if (Direction == TypeHierarchyDirection::Parents || ResolveLevels == 0)
|
|
return;
|
|
|
|
Item.children.emplace();
|
|
|
|
if (Index && Item.data) {
|
|
// We store the item's SymbolID in the 'data' field, and the client
|
|
// passes it back to us in typeHierarchy/resolve.
|
|
if (Expected<SymbolID> ID = SymbolID::fromStr(*Item.data)) {
|
|
fillSubTypes(*ID, *Item.children, Index, ResolveLevels, Item.uri.file());
|
|
}
|
|
}
|
|
}
|
|
|
|
FormattedString HoverInfo::present() const {
|
|
FormattedString Output;
|
|
if (NamespaceScope) {
|
|
Output.appendText("Declared in");
|
|
// Drop trailing "::".
|
|
if (!LocalScope.empty())
|
|
Output.appendInlineCode(llvm::StringRef(LocalScope).drop_back(2));
|
|
else if (NamespaceScope->empty())
|
|
Output.appendInlineCode("global namespace");
|
|
else
|
|
Output.appendInlineCode(llvm::StringRef(*NamespaceScope).drop_back(2));
|
|
}
|
|
|
|
if (!Definition.empty()) {
|
|
Output.appendCodeBlock(Definition);
|
|
} else {
|
|
// Builtin types
|
|
Output.appendCodeBlock(Name);
|
|
}
|
|
|
|
if (!Documentation.empty())
|
|
Output.appendText(Documentation);
|
|
return Output;
|
|
}
|
|
|
|
llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
|
|
const HoverInfo::Param &P) {
|
|
std::vector<llvm::StringRef> Output;
|
|
if (P.Type)
|
|
Output.push_back(*P.Type);
|
|
if (P.Name)
|
|
Output.push_back(*P.Name);
|
|
OS << llvm::join(Output, " ");
|
|
if (P.Default)
|
|
OS << " = " << *P.Default;
|
|
return OS;
|
|
}
|
|
|
|
llvm::DenseSet<const Decl *> getNonLocalDeclRefs(ParsedAST &AST,
|
|
const FunctionDecl *FD) {
|
|
if (!FD->hasBody())
|
|
return {};
|
|
llvm::DenseSet<const Decl *> DeclRefs;
|
|
findExplicitReferences(FD, [&](ReferenceLoc Ref) {
|
|
for (const Decl *D : Ref.Targets) {
|
|
if (!index::isFunctionLocalSymbol(D) && !D->isTemplateParameter() &&
|
|
!Ref.IsDecl)
|
|
DeclRefs.insert(D);
|
|
}
|
|
});
|
|
return DeclRefs;
|
|
}
|
|
} // namespace clangd
|
|
} // namespace clang
|