2017-12-20 01:06:07 +08:00
|
|
|
//===--- XRefs.cpp ----------------------------------------------*- C++-*-===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
#include "XRefs.h"
|
2018-03-09 22:00:34 +08:00
|
|
|
#include "AST.h"
|
2018-01-29 23:37:46 +08:00
|
|
|
#include "Logger.h"
|
2018-02-21 10:39:08 +08:00
|
|
|
#include "SourceCode.h"
|
2018-01-29 23:37:46 +08:00
|
|
|
#include "URI.h"
|
[clangd] Implement textDocument/hover
Summary: Implemention of textDocument/hover as described in LSP definition.
This patch adds a basic Hover implementation. When hovering a variable,
function, method or namespace, clangd will return a text containing the
declaration's scope, as well as the declaration of the hovered entity.
For example, for a variable:
Declared in class Foo::Bar
int hello = 2
For macros, the macro definition is returned.
This patch doesn't include:
- markdown support (the client I use doesn't support it yet)
- range support (optional in the Hover response)
- comments associated to variables/functions/classes
They are kept as future work to keep this patch simpler.
I added tests in XRefsTests.cpp. hover.test contains one simple
smoketest to make sure the feature works from a black box perspective.
Reviewers: malaperle, krasimir, bkramer, ilya-biryukov
Subscribers: sammccall, mgrang, klimek, rwols, ilya-biryukov, arphaman, cfe-commits
Differential Revision: https://reviews.llvm.org/D35894
Signed-off-by: Simon Marchi <simon.marchi@ericsson.com>
Signed-off-by: William Enright <william.enright@polymtl.ca>
llvm-svn: 325395
2018-02-17 05:38:15 +08:00
|
|
|
#include "clang/AST/DeclTemplate.h"
|
2018-07-03 00:28:34 +08:00
|
|
|
#include "clang/AST/RecursiveASTVisitor.h"
|
2017-12-20 01:06:07 +08:00
|
|
|
#include "clang/Index/IndexDataConsumer.h"
|
|
|
|
#include "clang/Index/IndexingAction.h"
|
2018-04-30 23:24:17 +08:00
|
|
|
#include "clang/Index/USRGeneration.h"
|
2018-02-14 01:47:16 +08:00
|
|
|
#include "llvm/Support/Path.h"
|
2017-12-20 01:06:07 +08:00
|
|
|
namespace clang {
|
|
|
|
namespace clangd {
|
|
|
|
using namespace llvm;
|
|
|
|
namespace {
|
|
|
|
|
2018-01-12 22:21:10 +08:00
|
|
|
// Get the definition from a given declaration `D`.
|
|
|
|
// Return nullptr if no definition is found, or the declaration type of `D` is
|
|
|
|
// not supported.
|
2018-07-26 20:05:31 +08:00
|
|
|
const Decl *getDefinition(const Decl *D) {
|
2018-01-12 22:21:10 +08:00
|
|
|
assert(D);
|
|
|
|
if (const auto *TD = dyn_cast<TagDecl>(D))
|
|
|
|
return TD->getDefinition();
|
|
|
|
else if (const auto *VD = dyn_cast<VarDecl>(D))
|
|
|
|
return VD->getDefinition();
|
|
|
|
else if (const auto *FD = dyn_cast<FunctionDecl>(D))
|
|
|
|
return FD->getDefinition();
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2018-04-30 23:24:17 +08:00
|
|
|
// Convert a SymbolLocation to LSP's Location.
|
|
|
|
// HintPath is used to resolve the path of URI.
|
|
|
|
// FIXME: figure out a good home for it, and share the implementation with
|
|
|
|
// FindSymbols.
|
2018-07-26 20:05:31 +08:00
|
|
|
llvm::Optional<Location> toLSPLocation(const SymbolLocation &Loc,
|
2018-04-30 23:24:17 +08:00
|
|
|
llvm::StringRef HintPath) {
|
|
|
|
if (!Loc)
|
|
|
|
return llvm::None;
|
|
|
|
auto Uri = URI::parse(Loc.FileURI);
|
|
|
|
if (!Uri) {
|
[clangd] Upgrade logging facilities with levels and formatv.
Summary:
log() is split into four functions:
- elog()/log()/vlog() have different severity levels, allowing filtering
- dlog() is a lazy macro which uses LLVM_DEBUG - it logs to the logger, but
conditionally based on -debug-only flag and is omitted in release builds
All logging functions use formatv-style format strings now, e.g:
log("Could not resolve URI {0}: {1}", URI, Result.takeError());
Existing log sites have been split between elog/log/vlog by best guess.
This includes a workaround for passing Error to formatv that can be
simplified when D49170 or similar lands.
Subscribers: ilya-biryukov, javed.absar, ioeric, MaskRay, jkorous, cfe-commits
Differential Revision: https://reviews.llvm.org/D49008
llvm-svn: 336785
2018-07-11 18:35:11 +08:00
|
|
|
log("Could not parse URI: {0}", Loc.FileURI);
|
2018-04-30 23:24:17 +08:00
|
|
|
return llvm::None;
|
|
|
|
}
|
|
|
|
auto Path = URI::resolve(*Uri, HintPath);
|
|
|
|
if (!Path) {
|
[clangd] Upgrade logging facilities with levels and formatv.
Summary:
log() is split into four functions:
- elog()/log()/vlog() have different severity levels, allowing filtering
- dlog() is a lazy macro which uses LLVM_DEBUG - it logs to the logger, but
conditionally based on -debug-only flag and is omitted in release builds
All logging functions use formatv-style format strings now, e.g:
log("Could not resolve URI {0}: {1}", URI, Result.takeError());
Existing log sites have been split between elog/log/vlog by best guess.
This includes a workaround for passing Error to formatv that can be
simplified when D49170 or similar lands.
Subscribers: ilya-biryukov, javed.absar, ioeric, MaskRay, jkorous, cfe-commits
Differential Revision: https://reviews.llvm.org/D49008
llvm-svn: 336785
2018-07-11 18:35:11 +08:00
|
|
|
log("Could not resolve URI: {0}", Loc.FileURI);
|
2018-04-30 23:24:17 +08:00
|
|
|
return llvm::None;
|
|
|
|
}
|
|
|
|
Location LSPLoc;
|
|
|
|
LSPLoc.uri = URIForFile(*Path);
|
|
|
|
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;
|
|
|
|
return LSPLoc;
|
|
|
|
}
|
|
|
|
|
[clangd] Implement textDocument/hover
Summary: Implemention of textDocument/hover as described in LSP definition.
This patch adds a basic Hover implementation. When hovering a variable,
function, method or namespace, clangd will return a text containing the
declaration's scope, as well as the declaration of the hovered entity.
For example, for a variable:
Declared in class Foo::Bar
int hello = 2
For macros, the macro definition is returned.
This patch doesn't include:
- markdown support (the client I use doesn't support it yet)
- range support (optional in the Hover response)
- comments associated to variables/functions/classes
They are kept as future work to keep this patch simpler.
I added tests in XRefsTests.cpp. hover.test contains one simple
smoketest to make sure the feature works from a black box perspective.
Reviewers: malaperle, krasimir, bkramer, ilya-biryukov
Subscribers: sammccall, mgrang, klimek, rwols, ilya-biryukov, arphaman, cfe-commits
Differential Revision: https://reviews.llvm.org/D35894
Signed-off-by: Simon Marchi <simon.marchi@ericsson.com>
Signed-off-by: William Enright <william.enright@polymtl.ca>
llvm-svn: 325395
2018-02-17 05:38:15 +08:00
|
|
|
struct MacroDecl {
|
|
|
|
StringRef Name;
|
|
|
|
const MacroInfo *Info;
|
|
|
|
};
|
|
|
|
|
2017-12-20 01:06:07 +08:00
|
|
|
/// Finds declarations locations that a given source location refers to.
|
|
|
|
class DeclarationAndMacrosFinder : public index::IndexDataConsumer {
|
|
|
|
std::vector<const Decl *> Decls;
|
[clangd] Implement textDocument/hover
Summary: Implemention of textDocument/hover as described in LSP definition.
This patch adds a basic Hover implementation. When hovering a variable,
function, method or namespace, clangd will return a text containing the
declaration's scope, as well as the declaration of the hovered entity.
For example, for a variable:
Declared in class Foo::Bar
int hello = 2
For macros, the macro definition is returned.
This patch doesn't include:
- markdown support (the client I use doesn't support it yet)
- range support (optional in the Hover response)
- comments associated to variables/functions/classes
They are kept as future work to keep this patch simpler.
I added tests in XRefsTests.cpp. hover.test contains one simple
smoketest to make sure the feature works from a black box perspective.
Reviewers: malaperle, krasimir, bkramer, ilya-biryukov
Subscribers: sammccall, mgrang, klimek, rwols, ilya-biryukov, arphaman, cfe-commits
Differential Revision: https://reviews.llvm.org/D35894
Signed-off-by: Simon Marchi <simon.marchi@ericsson.com>
Signed-off-by: William Enright <william.enright@polymtl.ca>
llvm-svn: 325395
2018-02-17 05:38:15 +08:00
|
|
|
std::vector<MacroDecl> MacroInfos;
|
2017-12-20 01:06:07 +08:00
|
|
|
const SourceLocation &SearchedLocation;
|
|
|
|
const ASTContext &AST;
|
|
|
|
Preprocessor &PP;
|
|
|
|
|
|
|
|
public:
|
|
|
|
DeclarationAndMacrosFinder(raw_ostream &OS,
|
|
|
|
const SourceLocation &SearchedLocation,
|
|
|
|
ASTContext &AST, Preprocessor &PP)
|
|
|
|
: SearchedLocation(SearchedLocation), AST(AST), PP(PP) {}
|
|
|
|
|
|
|
|
std::vector<const Decl *> takeDecls() {
|
|
|
|
// Don't keep the same declaration multiple times.
|
|
|
|
// This can happen when nodes in the AST are visited twice.
|
|
|
|
std::sort(Decls.begin(), Decls.end());
|
|
|
|
auto Last = std::unique(Decls.begin(), Decls.end());
|
|
|
|
Decls.erase(Last, Decls.end());
|
|
|
|
return std::move(Decls);
|
|
|
|
}
|
|
|
|
|
[clangd] Implement textDocument/hover
Summary: Implemention of textDocument/hover as described in LSP definition.
This patch adds a basic Hover implementation. When hovering a variable,
function, method or namespace, clangd will return a text containing the
declaration's scope, as well as the declaration of the hovered entity.
For example, for a variable:
Declared in class Foo::Bar
int hello = 2
For macros, the macro definition is returned.
This patch doesn't include:
- markdown support (the client I use doesn't support it yet)
- range support (optional in the Hover response)
- comments associated to variables/functions/classes
They are kept as future work to keep this patch simpler.
I added tests in XRefsTests.cpp. hover.test contains one simple
smoketest to make sure the feature works from a black box perspective.
Reviewers: malaperle, krasimir, bkramer, ilya-biryukov
Subscribers: sammccall, mgrang, klimek, rwols, ilya-biryukov, arphaman, cfe-commits
Differential Revision: https://reviews.llvm.org/D35894
Signed-off-by: Simon Marchi <simon.marchi@ericsson.com>
Signed-off-by: William Enright <william.enright@polymtl.ca>
llvm-svn: 325395
2018-02-17 05:38:15 +08:00
|
|
|
std::vector<MacroDecl> takeMacroInfos() {
|
2017-12-20 01:06:07 +08:00
|
|
|
// Don't keep the same Macro info multiple times.
|
[clangd] Implement textDocument/hover
Summary: Implemention of textDocument/hover as described in LSP definition.
This patch adds a basic Hover implementation. When hovering a variable,
function, method or namespace, clangd will return a text containing the
declaration's scope, as well as the declaration of the hovered entity.
For example, for a variable:
Declared in class Foo::Bar
int hello = 2
For macros, the macro definition is returned.
This patch doesn't include:
- markdown support (the client I use doesn't support it yet)
- range support (optional in the Hover response)
- comments associated to variables/functions/classes
They are kept as future work to keep this patch simpler.
I added tests in XRefsTests.cpp. hover.test contains one simple
smoketest to make sure the feature works from a black box perspective.
Reviewers: malaperle, krasimir, bkramer, ilya-biryukov
Subscribers: sammccall, mgrang, klimek, rwols, ilya-biryukov, arphaman, cfe-commits
Differential Revision: https://reviews.llvm.org/D35894
Signed-off-by: Simon Marchi <simon.marchi@ericsson.com>
Signed-off-by: William Enright <william.enright@polymtl.ca>
llvm-svn: 325395
2018-02-17 05:38:15 +08:00
|
|
|
std::sort(MacroInfos.begin(), MacroInfos.end(),
|
|
|
|
[](const MacroDecl &Left, const MacroDecl &Right) {
|
|
|
|
return Left.Info < Right.Info;
|
|
|
|
});
|
|
|
|
|
|
|
|
auto Last = std::unique(MacroInfos.begin(), MacroInfos.end(),
|
|
|
|
[](const MacroDecl &Left, const MacroDecl &Right) {
|
|
|
|
return Left.Info == Right.Info;
|
|
|
|
});
|
2017-12-20 01:06:07 +08:00
|
|
|
MacroInfos.erase(Last, MacroInfos.end());
|
|
|
|
return std::move(MacroInfos);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
handleDeclOccurence(const Decl *D, index::SymbolRoleSet Roles,
|
2018-04-09 22:28:52 +08:00
|
|
|
ArrayRef<index::SymbolRelation> Relations,
|
|
|
|
SourceLocation Loc,
|
2017-12-20 01:06:07 +08:00
|
|
|
index::IndexDataConsumer::ASTNodeInfo ASTNode) override {
|
2018-04-09 22:28:52 +08:00
|
|
|
if (Loc == SearchedLocation) {
|
2018-01-12 22:21:10 +08:00
|
|
|
// 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.
|
2018-07-26 20:05:31 +08:00
|
|
|
if (const auto *Def = getDefinition(D)) {
|
2018-01-12 22:21:10 +08:00
|
|
|
Decls.push_back(Def);
|
|
|
|
} else {
|
|
|
|
// Couldn't find a definition, fall back to use `D`.
|
|
|
|
Decls.push_back(D);
|
|
|
|
}
|
|
|
|
}
|
2017-12-20 01:06:07 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
void finish() override {
|
|
|
|
// Also handle possible macro at the searched location.
|
|
|
|
Token Result;
|
|
|
|
auto &Mgr = AST.getSourceManager();
|
2018-04-09 22:28:52 +08:00
|
|
|
if (!Lexer::getRawToken(Mgr.getSpellingLoc(SearchedLocation), Result, Mgr,
|
|
|
|
AST.getLangOpts(), false)) {
|
2017-12-20 01:06:07 +08:00
|
|
|
if (Result.is(tok::raw_identifier)) {
|
|
|
|
PP.LookUpIdentifierInfo(Result);
|
|
|
|
}
|
|
|
|
IdentifierInfo *IdentifierInfo = Result.getIdentifierInfo();
|
|
|
|
if (IdentifierInfo && IdentifierInfo->hadMacroDefinition()) {
|
|
|
|
std::pair<FileID, unsigned int> DecLoc =
|
|
|
|
Mgr.getDecomposedExpansionLoc(SearchedLocation);
|
|
|
|
// Get the definition just before the searched location so that a macro
|
|
|
|
// referenced in a '#undef MACRO' can still be found.
|
|
|
|
SourceLocation BeforeSearchedLocation = Mgr.getMacroArgExpandedLocation(
|
|
|
|
Mgr.getLocForStartOfFile(DecLoc.first)
|
|
|
|
.getLocWithOffset(DecLoc.second - 1));
|
|
|
|
MacroDefinition MacroDef =
|
|
|
|
PP.getMacroDefinitionAtLoc(IdentifierInfo, BeforeSearchedLocation);
|
|
|
|
MacroInfo *MacroInf = MacroDef.getMacroInfo();
|
|
|
|
if (MacroInf) {
|
[clangd] Implement textDocument/hover
Summary: Implemention of textDocument/hover as described in LSP definition.
This patch adds a basic Hover implementation. When hovering a variable,
function, method or namespace, clangd will return a text containing the
declaration's scope, as well as the declaration of the hovered entity.
For example, for a variable:
Declared in class Foo::Bar
int hello = 2
For macros, the macro definition is returned.
This patch doesn't include:
- markdown support (the client I use doesn't support it yet)
- range support (optional in the Hover response)
- comments associated to variables/functions/classes
They are kept as future work to keep this patch simpler.
I added tests in XRefsTests.cpp. hover.test contains one simple
smoketest to make sure the feature works from a black box perspective.
Reviewers: malaperle, krasimir, bkramer, ilya-biryukov
Subscribers: sammccall, mgrang, klimek, rwols, ilya-biryukov, arphaman, cfe-commits
Differential Revision: https://reviews.llvm.org/D35894
Signed-off-by: Simon Marchi <simon.marchi@ericsson.com>
Signed-off-by: William Enright <william.enright@polymtl.ca>
llvm-svn: 325395
2018-02-17 05:38:15 +08:00
|
|
|
MacroInfos.push_back(MacroDecl{IdentifierInfo->getName(), MacroInf});
|
2018-04-09 22:28:52 +08:00
|
|
|
assert(Decls.empty());
|
2017-12-20 01:06:07 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2018-04-30 23:24:17 +08:00
|
|
|
struct IdentifiedSymbol {
|
|
|
|
std::vector<const Decl *> Decls;
|
|
|
|
std::vector<MacroDecl> Macros;
|
|
|
|
};
|
|
|
|
|
|
|
|
IdentifiedSymbol getSymbolAtPosition(ParsedAST &AST, SourceLocation Pos) {
|
|
|
|
auto DeclMacrosFinder = DeclarationAndMacrosFinder(
|
|
|
|
llvm::errs(), Pos, AST.getASTContext(), AST.getPreprocessor());
|
|
|
|
index::IndexingOptions IndexOpts;
|
|
|
|
IndexOpts.SystemSymbolFilter =
|
|
|
|
index::IndexingOptions::SystemSymbolFilterKind::All;
|
|
|
|
IndexOpts.IndexFunctionLocals = true;
|
2018-05-28 20:23:17 +08:00
|
|
|
indexTopLevelDecls(AST.getASTContext(), AST.getLocalTopLevelDecls(),
|
2018-04-30 23:24:17 +08:00
|
|
|
DeclMacrosFinder, IndexOpts);
|
|
|
|
|
|
|
|
return {DeclMacrosFinder.takeDecls(), DeclMacrosFinder.takeMacroInfos()};
|
|
|
|
}
|
|
|
|
|
2017-12-20 01:06:07 +08:00
|
|
|
llvm::Optional<Location>
|
2018-03-09 22:00:34 +08:00
|
|
|
makeLocation(ParsedAST &AST, const SourceRange &ValSourceRange) {
|
2017-12-20 01:06:07 +08:00
|
|
|
const SourceManager &SourceMgr = AST.getASTContext().getSourceManager();
|
|
|
|
const LangOptions &LangOpts = AST.getASTContext().getLangOpts();
|
|
|
|
SourceLocation LocStart = ValSourceRange.getBegin();
|
|
|
|
|
|
|
|
const FileEntry *F =
|
|
|
|
SourceMgr.getFileEntryForID(SourceMgr.getFileID(LocStart));
|
|
|
|
if (!F)
|
|
|
|
return llvm::None;
|
|
|
|
SourceLocation LocEnd = Lexer::getLocForEndOfToken(ValSourceRange.getEnd(), 0,
|
|
|
|
SourceMgr, LangOpts);
|
2018-02-21 10:39:08 +08:00
|
|
|
Position Begin = sourceLocToPosition(SourceMgr, LocStart);
|
|
|
|
Position End = sourceLocToPosition(SourceMgr, LocEnd);
|
2017-12-20 01:06:07 +08:00
|
|
|
Range R = {Begin, End};
|
|
|
|
Location L;
|
|
|
|
|
2018-04-30 23:24:17 +08:00
|
|
|
auto FilePath = getAbsoluteFilePath(F, SourceMgr);
|
|
|
|
if (!FilePath) {
|
|
|
|
log("failed to get path!");
|
|
|
|
return llvm::None;
|
2018-02-14 01:47:16 +08:00
|
|
|
}
|
2018-04-30 23:24:17 +08:00
|
|
|
L.uri = URIForFile(*FilePath);
|
2017-12-20 01:06:07 +08:00
|
|
|
L.range = R;
|
|
|
|
return L;
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace
|
|
|
|
|
2018-04-30 23:24:17 +08:00
|
|
|
std::vector<Location> findDefinitions(ParsedAST &AST, Position Pos,
|
|
|
|
const SymbolIndex *Index) {
|
2017-12-20 01:06:07 +08:00
|
|
|
const SourceManager &SourceMgr = AST.getASTContext().getSourceManager();
|
|
|
|
|
2018-03-09 00:28:12 +08:00
|
|
|
std::vector<Location> Result;
|
|
|
|
// Handle goto definition for #include.
|
2018-07-03 16:09:29 +08:00
|
|
|
for (auto &Inc : AST.getIncludeStructure().MainFileIncludes) {
|
2018-05-14 20:19:16 +08:00
|
|
|
if (!Inc.Resolved.empty() && Inc.R.contains(Pos))
|
|
|
|
Result.push_back(Location{URIForFile{Inc.Resolved}, {}});
|
2018-03-09 00:28:12 +08:00
|
|
|
}
|
|
|
|
if (!Result.empty())
|
|
|
|
return Result;
|
|
|
|
|
2018-04-30 23:24:17 +08:00
|
|
|
// Identified symbols at a specific position.
|
2018-07-03 16:09:29 +08:00
|
|
|
SourceLocation SourceLocationBeg =
|
|
|
|
getBeginningOfIdentifier(AST, Pos, SourceMgr.getMainFileID());
|
2018-04-30 23:24:17 +08:00
|
|
|
auto Symbols = getSymbolAtPosition(AST, SourceLocationBeg);
|
2017-12-20 01:06:07 +08:00
|
|
|
|
2018-04-30 23:24:17 +08:00
|
|
|
for (auto Item : Symbols.Macros) {
|
|
|
|
auto Loc = Item.Info->getDefinitionLoc();
|
2018-03-09 22:00:34 +08:00
|
|
|
auto L = makeLocation(AST, SourceRange(Loc, Loc));
|
2017-12-20 01:06:07 +08:00
|
|
|
if (L)
|
|
|
|
Result.push_back(*L);
|
|
|
|
}
|
|
|
|
|
2018-04-30 23:24:17 +08:00
|
|
|
// Declaration and definition are different terms in C-family languages, and
|
|
|
|
// LSP only defines the "GoToDefinition" specification, so we try to perform
|
|
|
|
// the "most sensible" GoTo operation:
|
|
|
|
//
|
|
|
|
// - We use the location from AST and index (if available) to provide the
|
|
|
|
// final results. When there are duplicate results, we prefer AST over
|
|
|
|
// index because AST is more up-to-date.
|
|
|
|
//
|
|
|
|
// - For each symbol, we will return a location of the canonical declaration
|
|
|
|
// (e.g. function declaration in header), and a location of definition if
|
|
|
|
// they are available.
|
|
|
|
//
|
|
|
|
// So the work flow:
|
|
|
|
//
|
|
|
|
// 1. Identify the symbols being search for by traversing the AST.
|
|
|
|
// 2. Populate one of the locations with the AST location.
|
|
|
|
// 3. Use the AST information to query the index, and populate the index
|
|
|
|
// location (if available).
|
|
|
|
// 4. Return all populated locations for all symbols, definition first (
|
|
|
|
// which we think is the users wants most often).
|
|
|
|
struct CandidateLocation {
|
|
|
|
llvm::Optional<Location> Def;
|
|
|
|
llvm::Optional<Location> Decl;
|
|
|
|
};
|
|
|
|
llvm::DenseMap<SymbolID, CandidateLocation> ResultCandidates;
|
|
|
|
|
|
|
|
// Emit all symbol locations (declaration or definition) from AST.
|
|
|
|
for (const auto *D : Symbols.Decls) {
|
|
|
|
// Fake key for symbols don't have USR (no SymbolID).
|
|
|
|
// Ideally, there should be a USR for each identified symbols. Symbols
|
|
|
|
// without USR are rare and unimportant cases, we use the a fake holder to
|
|
|
|
// minimize the invasiveness of these cases.
|
|
|
|
SymbolID Key("");
|
|
|
|
if (auto ID = getSymbolID(D))
|
|
|
|
Key = *ID;
|
|
|
|
|
|
|
|
auto &Candidate = ResultCandidates[Key];
|
|
|
|
auto Loc = findNameLoc(D);
|
2018-03-13 22:31:31 +08:00
|
|
|
auto L = makeLocation(AST, SourceRange(Loc, Loc));
|
2018-04-30 23:24:17 +08:00
|
|
|
// The declaration in the identified symbols is a definition if possible
|
|
|
|
// otherwise it is declaration.
|
2018-07-26 20:05:31 +08:00
|
|
|
bool IsDef = getDefinition(D) == D;
|
2018-04-30 23:24:17 +08:00
|
|
|
// Populate one of the slots with location for the AST.
|
|
|
|
if (!IsDef)
|
|
|
|
Candidate.Decl = L;
|
|
|
|
else
|
|
|
|
Candidate.Def = L;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Index) {
|
|
|
|
LookupRequest QueryRequest;
|
|
|
|
// Build request for index query, using SymbolID.
|
|
|
|
for (auto It : ResultCandidates)
|
|
|
|
QueryRequest.IDs.insert(It.first);
|
|
|
|
std::string HintPath;
|
|
|
|
const FileEntry *FE =
|
|
|
|
SourceMgr.getFileEntryForID(SourceMgr.getMainFileID());
|
|
|
|
if (auto Path = getAbsoluteFilePath(FE, SourceMgr))
|
|
|
|
HintPath = *Path;
|
|
|
|
// Query the index and populate the empty slot.
|
|
|
|
Index->lookup(
|
|
|
|
QueryRequest, [&HintPath, &ResultCandidates](const Symbol &Sym) {
|
|
|
|
auto It = ResultCandidates.find(Sym.ID);
|
|
|
|
assert(It != ResultCandidates.end());
|
|
|
|
auto &Value = It->second;
|
|
|
|
|
|
|
|
if (!Value.Def)
|
2018-07-26 20:05:31 +08:00
|
|
|
Value.Def = toLSPLocation(Sym.Definition, HintPath);
|
2018-04-30 23:24:17 +08:00
|
|
|
if (!Value.Decl)
|
2018-07-26 20:05:31 +08:00
|
|
|
Value.Decl = toLSPLocation(Sym.CanonicalDeclaration, HintPath);
|
2018-04-30 23:24:17 +08:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
// Populate the results, definition first.
|
|
|
|
for (auto It : ResultCandidates) {
|
|
|
|
const auto &Candidate = It.second;
|
|
|
|
if (Candidate.Def)
|
|
|
|
Result.push_back(*Candidate.Def);
|
|
|
|
if (Candidate.Decl &&
|
|
|
|
Candidate.Decl != Candidate.Def) // Decl and Def might be the same
|
|
|
|
Result.push_back(*Candidate.Decl);
|
2017-12-20 01:06:07 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
/// Finds document highlights that a given list of declarations refers to.
|
|
|
|
class DocumentHighlightsFinder : public index::IndexDataConsumer {
|
|
|
|
std::vector<const Decl *> &Decls;
|
|
|
|
std::vector<DocumentHighlight> DocumentHighlights;
|
|
|
|
const ASTContext &AST;
|
|
|
|
|
|
|
|
public:
|
|
|
|
DocumentHighlightsFinder(raw_ostream &OS, ASTContext &AST, Preprocessor &PP,
|
|
|
|
std::vector<const Decl *> &Decls)
|
|
|
|
: Decls(Decls), AST(AST) {}
|
|
|
|
std::vector<DocumentHighlight> takeHighlights() {
|
|
|
|
// Don't keep the same highlight multiple times.
|
|
|
|
// This can happen when nodes in the AST are visited twice.
|
|
|
|
std::sort(DocumentHighlights.begin(), DocumentHighlights.end());
|
|
|
|
auto Last =
|
|
|
|
std::unique(DocumentHighlights.begin(), DocumentHighlights.end());
|
|
|
|
DocumentHighlights.erase(Last, DocumentHighlights.end());
|
|
|
|
return std::move(DocumentHighlights);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
handleDeclOccurence(const Decl *D, index::SymbolRoleSet Roles,
|
2018-04-09 22:28:52 +08:00
|
|
|
ArrayRef<index::SymbolRelation> Relations,
|
|
|
|
SourceLocation Loc,
|
2017-12-20 01:06:07 +08:00
|
|
|
index::IndexDataConsumer::ASTNodeInfo ASTNode) override {
|
|
|
|
const SourceManager &SourceMgr = AST.getSourceManager();
|
2018-04-09 22:28:52 +08:00
|
|
|
SourceLocation HighlightStartLoc = SourceMgr.getFileLoc(Loc);
|
|
|
|
if (SourceMgr.getMainFileID() != SourceMgr.getFileID(HighlightStartLoc) ||
|
2017-12-20 01:06:07 +08:00
|
|
|
std::find(Decls.begin(), Decls.end(), D) == Decls.end()) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
SourceLocation End;
|
|
|
|
const LangOptions &LangOpts = AST.getLangOpts();
|
2018-04-09 22:28:52 +08:00
|
|
|
End = Lexer::getLocForEndOfToken(HighlightStartLoc, 0, SourceMgr, LangOpts);
|
|
|
|
SourceRange SR(HighlightStartLoc, End);
|
2017-12-20 01:06:07 +08:00
|
|
|
|
|
|
|
DocumentHighlightKind Kind = DocumentHighlightKind::Text;
|
|
|
|
if (static_cast<index::SymbolRoleSet>(index::SymbolRole::Write) & Roles)
|
|
|
|
Kind = DocumentHighlightKind::Write;
|
|
|
|
else if (static_cast<index::SymbolRoleSet>(index::SymbolRole::Read) & Roles)
|
|
|
|
Kind = DocumentHighlightKind::Read;
|
|
|
|
|
|
|
|
DocumentHighlights.push_back(getDocumentHighlight(SR, Kind));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
DocumentHighlight getDocumentHighlight(SourceRange SR,
|
|
|
|
DocumentHighlightKind Kind) {
|
|
|
|
const SourceManager &SourceMgr = AST.getSourceManager();
|
2018-02-21 10:39:08 +08:00
|
|
|
Position Begin = sourceLocToPosition(SourceMgr, SR.getBegin());
|
|
|
|
Position End = sourceLocToPosition(SourceMgr, SR.getEnd());
|
2017-12-20 01:06:07 +08:00
|
|
|
Range R = {Begin, End};
|
|
|
|
DocumentHighlight DH;
|
|
|
|
DH.range = R;
|
|
|
|
DH.kind = Kind;
|
|
|
|
return DH;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
} // namespace
|
|
|
|
|
[clangd] Pass Context implicitly using TLS.
Summary:
Instead of passing Context explicitly around, we now have a thread-local
Context object `Context::current()` which is an implicit argument to
every function.
Most manipulation of this should use the WithContextValue helper, which
augments the current Context to add a single KV pair, and restores the
old context on destruction.
Advantages are:
- less boilerplate in functions that just propagate contexts
- reading most code doesn't require understanding context at all, and
using context as values in fewer places still
- fewer options to pass the "wrong" context when it changes within a
scope (e.g. when using Span)
- contexts pass through interfaces we can't modify, such as VFS
- propagating contexts across threads was slightly tricky (e.g.
copy vs move, no move-init in lambdas), and is now encapsulated in
the threadpool
Disadvantages are all the usual TLS stuff - hidden magic, and
potential for higher memory usage on threads that don't use the
context. (In practice, it's just one pointer)
Reviewers: ilya-biryukov
Subscribers: klimek, jkorous-apple, ioeric, cfe-commits
Differential Revision: https://reviews.llvm.org/D42517
llvm-svn: 323872
2018-01-31 21:40:48 +08:00
|
|
|
std::vector<DocumentHighlight> findDocumentHighlights(ParsedAST &AST,
|
|
|
|
Position Pos) {
|
2017-12-20 01:06:07 +08:00
|
|
|
const SourceManager &SourceMgr = AST.getASTContext().getSourceManager();
|
[clangd] Fix unicode handling, using UTF-16 where LSP requires it.
Summary:
The Language Server Protocol unfortunately mandates that locations in files
be represented by line/column pairs, where the "column" is actually an index
into the UTF-16-encoded text of the line.
(This is because VSCode is written in JavaScript, which is UTF-16-native).
Internally clangd treats source files at UTF-8, the One True Encoding, and
generally deals with byte offsets (though there are exceptions).
Before this patch, conversions between offsets and LSP Position pretended
that Position.character was UTF-8 bytes, which is only true for ASCII lines.
Now we examine the text to convert correctly (but don't actually need to
transcode it, due to some nice details of the encodings).
The updated functions in SourceCode are the blessed way to interact with
the Position.character field, and anything else is likely to be wrong.
So I also updated the other accesses:
- CodeComplete needs a "clang-style" line/column, with column in utf-8 bytes.
This is now converted via Position -> offset -> clang line/column
(a new function is added to SourceCode.h for the second conversion).
- getBeginningOfIdentifier skipped backwards in UTF-16 space, which is will
behave badly when it splits a surrogate pair. Skipping backwards in UTF-8
coordinates gives the lexer a fighting chance of getting this right.
While here, I clarified(?) the logic comments, fixed a bug with identifiers
containing digits, simplified the signature slightly and added a test.
This seems likely to cause problems with editors that have the same bug, and
treat the protocol as if columns are UTF-8 bytes. But we can find and fix those.
Reviewers: hokein
Subscribers: klimek, ilya-biryukov, ioeric, MaskRay, jkorous, cfe-commits
Differential Revision: https://reviews.llvm.org/D46035
llvm-svn: 331029
2018-04-27 19:59:28 +08:00
|
|
|
SourceLocation SourceLocationBeg =
|
|
|
|
getBeginningOfIdentifier(AST, Pos, SourceMgr.getMainFileID());
|
2017-12-20 01:06:07 +08:00
|
|
|
|
2018-04-30 23:24:17 +08:00
|
|
|
auto Symbols = getSymbolAtPosition(AST, SourceLocationBeg);
|
|
|
|
std::vector<const Decl *> SelectedDecls = Symbols.Decls;
|
2017-12-20 01:06:07 +08:00
|
|
|
|
2018-04-23 22:30:21 +08:00
|
|
|
DocumentHighlightsFinder DocHighlightsFinder(
|
2017-12-20 01:06:07 +08:00
|
|
|
llvm::errs(), AST.getASTContext(), AST.getPreprocessor(), SelectedDecls);
|
|
|
|
|
2018-04-30 23:24:17 +08:00
|
|
|
index::IndexingOptions IndexOpts;
|
|
|
|
IndexOpts.SystemSymbolFilter =
|
|
|
|
index::IndexingOptions::SystemSymbolFilterKind::All;
|
|
|
|
IndexOpts.IndexFunctionLocals = true;
|
2018-05-28 20:23:17 +08:00
|
|
|
indexTopLevelDecls(AST.getASTContext(), AST.getLocalTopLevelDecls(),
|
2017-12-20 01:06:07 +08:00
|
|
|
DocHighlightsFinder, IndexOpts);
|
|
|
|
|
2018-04-23 22:30:21 +08:00
|
|
|
return DocHighlightsFinder.takeHighlights();
|
2017-12-20 01:06:07 +08:00
|
|
|
}
|
|
|
|
|
2018-07-26 20:05:31 +08:00
|
|
|
static PrintingPolicy printingPolicyForDecls(PrintingPolicy Base) {
|
[clangd] Implement textDocument/hover
Summary: Implemention of textDocument/hover as described in LSP definition.
This patch adds a basic Hover implementation. When hovering a variable,
function, method or namespace, clangd will return a text containing the
declaration's scope, as well as the declaration of the hovered entity.
For example, for a variable:
Declared in class Foo::Bar
int hello = 2
For macros, the macro definition is returned.
This patch doesn't include:
- markdown support (the client I use doesn't support it yet)
- range support (optional in the Hover response)
- comments associated to variables/functions/classes
They are kept as future work to keep this patch simpler.
I added tests in XRefsTests.cpp. hover.test contains one simple
smoketest to make sure the feature works from a black box perspective.
Reviewers: malaperle, krasimir, bkramer, ilya-biryukov
Subscribers: sammccall, mgrang, klimek, rwols, ilya-biryukov, arphaman, cfe-commits
Differential Revision: https://reviews.llvm.org/D35894
Signed-off-by: Simon Marchi <simon.marchi@ericsson.com>
Signed-off-by: William Enright <william.enright@polymtl.ca>
llvm-svn: 325395
2018-02-17 05:38:15 +08:00
|
|
|
PrintingPolicy Policy(Base);
|
|
|
|
|
|
|
|
Policy.AnonymousTagLocations = false;
|
|
|
|
Policy.TerseOutput = true;
|
|
|
|
Policy.PolishForDeclaration = true;
|
|
|
|
Policy.ConstantsAsWritten = true;
|
|
|
|
Policy.SuppressTagKeyword = false;
|
|
|
|
|
|
|
|
return Policy;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Return a string representation (e.g. "class MyNamespace::MyClass") of
|
|
|
|
/// the type declaration \p TD.
|
2018-07-26 20:05:31 +08:00
|
|
|
static std::string typeDeclToString(const TypeDecl *TD) {
|
[clangd] Implement textDocument/hover
Summary: Implemention of textDocument/hover as described in LSP definition.
This patch adds a basic Hover implementation. When hovering a variable,
function, method or namespace, clangd will return a text containing the
declaration's scope, as well as the declaration of the hovered entity.
For example, for a variable:
Declared in class Foo::Bar
int hello = 2
For macros, the macro definition is returned.
This patch doesn't include:
- markdown support (the client I use doesn't support it yet)
- range support (optional in the Hover response)
- comments associated to variables/functions/classes
They are kept as future work to keep this patch simpler.
I added tests in XRefsTests.cpp. hover.test contains one simple
smoketest to make sure the feature works from a black box perspective.
Reviewers: malaperle, krasimir, bkramer, ilya-biryukov
Subscribers: sammccall, mgrang, klimek, rwols, ilya-biryukov, arphaman, cfe-commits
Differential Revision: https://reviews.llvm.org/D35894
Signed-off-by: Simon Marchi <simon.marchi@ericsson.com>
Signed-off-by: William Enright <william.enright@polymtl.ca>
llvm-svn: 325395
2018-02-17 05:38:15 +08:00
|
|
|
QualType Type = TD->getASTContext().getTypeDeclType(TD);
|
|
|
|
|
|
|
|
PrintingPolicy Policy =
|
2018-07-26 20:05:31 +08:00
|
|
|
printingPolicyForDecls(TD->getASTContext().getPrintingPolicy());
|
[clangd] Implement textDocument/hover
Summary: Implemention of textDocument/hover as described in LSP definition.
This patch adds a basic Hover implementation. When hovering a variable,
function, method or namespace, clangd will return a text containing the
declaration's scope, as well as the declaration of the hovered entity.
For example, for a variable:
Declared in class Foo::Bar
int hello = 2
For macros, the macro definition is returned.
This patch doesn't include:
- markdown support (the client I use doesn't support it yet)
- range support (optional in the Hover response)
- comments associated to variables/functions/classes
They are kept as future work to keep this patch simpler.
I added tests in XRefsTests.cpp. hover.test contains one simple
smoketest to make sure the feature works from a black box perspective.
Reviewers: malaperle, krasimir, bkramer, ilya-biryukov
Subscribers: sammccall, mgrang, klimek, rwols, ilya-biryukov, arphaman, cfe-commits
Differential Revision: https://reviews.llvm.org/D35894
Signed-off-by: Simon Marchi <simon.marchi@ericsson.com>
Signed-off-by: William Enright <william.enright@polymtl.ca>
llvm-svn: 325395
2018-02-17 05:38:15 +08:00
|
|
|
|
|
|
|
std::string Name;
|
|
|
|
llvm::raw_string_ostream Stream(Name);
|
|
|
|
Type.print(Stream, Policy);
|
|
|
|
|
|
|
|
return Stream.str();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Return a string representation (e.g. "namespace ns1::ns2") of
|
|
|
|
/// the named declaration \p ND.
|
2018-07-26 20:05:31 +08:00
|
|
|
static std::string namedDeclQualifiedName(const NamedDecl *ND,
|
[clangd] Implement textDocument/hover
Summary: Implemention of textDocument/hover as described in LSP definition.
This patch adds a basic Hover implementation. When hovering a variable,
function, method or namespace, clangd will return a text containing the
declaration's scope, as well as the declaration of the hovered entity.
For example, for a variable:
Declared in class Foo::Bar
int hello = 2
For macros, the macro definition is returned.
This patch doesn't include:
- markdown support (the client I use doesn't support it yet)
- range support (optional in the Hover response)
- comments associated to variables/functions/classes
They are kept as future work to keep this patch simpler.
I added tests in XRefsTests.cpp. hover.test contains one simple
smoketest to make sure the feature works from a black box perspective.
Reviewers: malaperle, krasimir, bkramer, ilya-biryukov
Subscribers: sammccall, mgrang, klimek, rwols, ilya-biryukov, arphaman, cfe-commits
Differential Revision: https://reviews.llvm.org/D35894
Signed-off-by: Simon Marchi <simon.marchi@ericsson.com>
Signed-off-by: William Enright <william.enright@polymtl.ca>
llvm-svn: 325395
2018-02-17 05:38:15 +08:00
|
|
|
StringRef Prefix) {
|
|
|
|
PrintingPolicy Policy =
|
2018-07-26 20:05:31 +08:00
|
|
|
printingPolicyForDecls(ND->getASTContext().getPrintingPolicy());
|
[clangd] Implement textDocument/hover
Summary: Implemention of textDocument/hover as described in LSP definition.
This patch adds a basic Hover implementation. When hovering a variable,
function, method or namespace, clangd will return a text containing the
declaration's scope, as well as the declaration of the hovered entity.
For example, for a variable:
Declared in class Foo::Bar
int hello = 2
For macros, the macro definition is returned.
This patch doesn't include:
- markdown support (the client I use doesn't support it yet)
- range support (optional in the Hover response)
- comments associated to variables/functions/classes
They are kept as future work to keep this patch simpler.
I added tests in XRefsTests.cpp. hover.test contains one simple
smoketest to make sure the feature works from a black box perspective.
Reviewers: malaperle, krasimir, bkramer, ilya-biryukov
Subscribers: sammccall, mgrang, klimek, rwols, ilya-biryukov, arphaman, cfe-commits
Differential Revision: https://reviews.llvm.org/D35894
Signed-off-by: Simon Marchi <simon.marchi@ericsson.com>
Signed-off-by: William Enright <william.enright@polymtl.ca>
llvm-svn: 325395
2018-02-17 05:38:15 +08:00
|
|
|
|
|
|
|
std::string Name;
|
|
|
|
llvm::raw_string_ostream Stream(Name);
|
|
|
|
Stream << Prefix << ' ';
|
|
|
|
ND->printQualifiedName(Stream, Policy);
|
|
|
|
|
|
|
|
return Stream.str();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Given a declaration \p D, return a human-readable string representing the
|
|
|
|
/// scope in which it is declared. If the declaration is in the global scope,
|
|
|
|
/// return the string "global namespace".
|
|
|
|
static llvm::Optional<std::string> getScopeName(const Decl *D) {
|
|
|
|
const DeclContext *DC = D->getDeclContext();
|
|
|
|
|
2018-02-19 17:31:26 +08:00
|
|
|
if (isa<TranslationUnitDecl>(DC))
|
[clangd] Implement textDocument/hover
Summary: Implemention of textDocument/hover as described in LSP definition.
This patch adds a basic Hover implementation. When hovering a variable,
function, method or namespace, clangd will return a text containing the
declaration's scope, as well as the declaration of the hovered entity.
For example, for a variable:
Declared in class Foo::Bar
int hello = 2
For macros, the macro definition is returned.
This patch doesn't include:
- markdown support (the client I use doesn't support it yet)
- range support (optional in the Hover response)
- comments associated to variables/functions/classes
They are kept as future work to keep this patch simpler.
I added tests in XRefsTests.cpp. hover.test contains one simple
smoketest to make sure the feature works from a black box perspective.
Reviewers: malaperle, krasimir, bkramer, ilya-biryukov
Subscribers: sammccall, mgrang, klimek, rwols, ilya-biryukov, arphaman, cfe-commits
Differential Revision: https://reviews.llvm.org/D35894
Signed-off-by: Simon Marchi <simon.marchi@ericsson.com>
Signed-off-by: William Enright <william.enright@polymtl.ca>
llvm-svn: 325395
2018-02-17 05:38:15 +08:00
|
|
|
return std::string("global namespace");
|
|
|
|
if (const TypeDecl *TD = dyn_cast<TypeDecl>(DC))
|
2018-07-26 20:05:31 +08:00
|
|
|
return typeDeclToString(TD);
|
[clangd] Implement textDocument/hover
Summary: Implemention of textDocument/hover as described in LSP definition.
This patch adds a basic Hover implementation. When hovering a variable,
function, method or namespace, clangd will return a text containing the
declaration's scope, as well as the declaration of the hovered entity.
For example, for a variable:
Declared in class Foo::Bar
int hello = 2
For macros, the macro definition is returned.
This patch doesn't include:
- markdown support (the client I use doesn't support it yet)
- range support (optional in the Hover response)
- comments associated to variables/functions/classes
They are kept as future work to keep this patch simpler.
I added tests in XRefsTests.cpp. hover.test contains one simple
smoketest to make sure the feature works from a black box perspective.
Reviewers: malaperle, krasimir, bkramer, ilya-biryukov
Subscribers: sammccall, mgrang, klimek, rwols, ilya-biryukov, arphaman, cfe-commits
Differential Revision: https://reviews.llvm.org/D35894
Signed-off-by: Simon Marchi <simon.marchi@ericsson.com>
Signed-off-by: William Enright <william.enright@polymtl.ca>
llvm-svn: 325395
2018-02-17 05:38:15 +08:00
|
|
|
else if (const NamespaceDecl *ND = dyn_cast<NamespaceDecl>(DC))
|
2018-07-26 20:05:31 +08:00
|
|
|
return namedDeclQualifiedName(ND, "namespace");
|
[clangd] Implement textDocument/hover
Summary: Implemention of textDocument/hover as described in LSP definition.
This patch adds a basic Hover implementation. When hovering a variable,
function, method or namespace, clangd will return a text containing the
declaration's scope, as well as the declaration of the hovered entity.
For example, for a variable:
Declared in class Foo::Bar
int hello = 2
For macros, the macro definition is returned.
This patch doesn't include:
- markdown support (the client I use doesn't support it yet)
- range support (optional in the Hover response)
- comments associated to variables/functions/classes
They are kept as future work to keep this patch simpler.
I added tests in XRefsTests.cpp. hover.test contains one simple
smoketest to make sure the feature works from a black box perspective.
Reviewers: malaperle, krasimir, bkramer, ilya-biryukov
Subscribers: sammccall, mgrang, klimek, rwols, ilya-biryukov, arphaman, cfe-commits
Differential Revision: https://reviews.llvm.org/D35894
Signed-off-by: Simon Marchi <simon.marchi@ericsson.com>
Signed-off-by: William Enright <william.enright@polymtl.ca>
llvm-svn: 325395
2018-02-17 05:38:15 +08:00
|
|
|
else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(DC))
|
2018-07-26 20:05:31 +08:00
|
|
|
return namedDeclQualifiedName(FD, "function");
|
[clangd] Implement textDocument/hover
Summary: Implemention of textDocument/hover as described in LSP definition.
This patch adds a basic Hover implementation. When hovering a variable,
function, method or namespace, clangd will return a text containing the
declaration's scope, as well as the declaration of the hovered entity.
For example, for a variable:
Declared in class Foo::Bar
int hello = 2
For macros, the macro definition is returned.
This patch doesn't include:
- markdown support (the client I use doesn't support it yet)
- range support (optional in the Hover response)
- comments associated to variables/functions/classes
They are kept as future work to keep this patch simpler.
I added tests in XRefsTests.cpp. hover.test contains one simple
smoketest to make sure the feature works from a black box perspective.
Reviewers: malaperle, krasimir, bkramer, ilya-biryukov
Subscribers: sammccall, mgrang, klimek, rwols, ilya-biryukov, arphaman, cfe-commits
Differential Revision: https://reviews.llvm.org/D35894
Signed-off-by: Simon Marchi <simon.marchi@ericsson.com>
Signed-off-by: William Enright <william.enright@polymtl.ca>
llvm-svn: 325395
2018-02-17 05:38:15 +08:00
|
|
|
|
|
|
|
return llvm::None;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Generate a \p Hover object given the declaration \p D.
|
|
|
|
static Hover getHoverContents(const Decl *D) {
|
|
|
|
Hover H;
|
|
|
|
llvm::Optional<std::string> NamedScope = getScopeName(D);
|
|
|
|
|
|
|
|
// Generate the "Declared in" section.
|
|
|
|
if (NamedScope) {
|
|
|
|
assert(!NamedScope->empty());
|
|
|
|
|
2018-02-17 07:12:26 +08:00
|
|
|
H.contents.value += "Declared in ";
|
|
|
|
H.contents.value += *NamedScope;
|
|
|
|
H.contents.value += "\n\n";
|
[clangd] Implement textDocument/hover
Summary: Implemention of textDocument/hover as described in LSP definition.
This patch adds a basic Hover implementation. When hovering a variable,
function, method or namespace, clangd will return a text containing the
declaration's scope, as well as the declaration of the hovered entity.
For example, for a variable:
Declared in class Foo::Bar
int hello = 2
For macros, the macro definition is returned.
This patch doesn't include:
- markdown support (the client I use doesn't support it yet)
- range support (optional in the Hover response)
- comments associated to variables/functions/classes
They are kept as future work to keep this patch simpler.
I added tests in XRefsTests.cpp. hover.test contains one simple
smoketest to make sure the feature works from a black box perspective.
Reviewers: malaperle, krasimir, bkramer, ilya-biryukov
Subscribers: sammccall, mgrang, klimek, rwols, ilya-biryukov, arphaman, cfe-commits
Differential Revision: https://reviews.llvm.org/D35894
Signed-off-by: Simon Marchi <simon.marchi@ericsson.com>
Signed-off-by: William Enright <william.enright@polymtl.ca>
llvm-svn: 325395
2018-02-17 05:38:15 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// We want to include the template in the Hover.
|
|
|
|
if (TemplateDecl *TD = D->getDescribedTemplate())
|
|
|
|
D = TD;
|
|
|
|
|
|
|
|
std::string DeclText;
|
|
|
|
llvm::raw_string_ostream OS(DeclText);
|
|
|
|
|
|
|
|
PrintingPolicy Policy =
|
2018-07-26 20:05:31 +08:00
|
|
|
printingPolicyForDecls(D->getASTContext().getPrintingPolicy());
|
[clangd] Implement textDocument/hover
Summary: Implemention of textDocument/hover as described in LSP definition.
This patch adds a basic Hover implementation. When hovering a variable,
function, method or namespace, clangd will return a text containing the
declaration's scope, as well as the declaration of the hovered entity.
For example, for a variable:
Declared in class Foo::Bar
int hello = 2
For macros, the macro definition is returned.
This patch doesn't include:
- markdown support (the client I use doesn't support it yet)
- range support (optional in the Hover response)
- comments associated to variables/functions/classes
They are kept as future work to keep this patch simpler.
I added tests in XRefsTests.cpp. hover.test contains one simple
smoketest to make sure the feature works from a black box perspective.
Reviewers: malaperle, krasimir, bkramer, ilya-biryukov
Subscribers: sammccall, mgrang, klimek, rwols, ilya-biryukov, arphaman, cfe-commits
Differential Revision: https://reviews.llvm.org/D35894
Signed-off-by: Simon Marchi <simon.marchi@ericsson.com>
Signed-off-by: William Enright <william.enright@polymtl.ca>
llvm-svn: 325395
2018-02-17 05:38:15 +08:00
|
|
|
|
|
|
|
D->print(OS, Policy);
|
|
|
|
|
|
|
|
OS.flush();
|
|
|
|
|
2018-02-17 07:12:26 +08:00
|
|
|
H.contents.value += DeclText;
|
[clangd] Implement textDocument/hover
Summary: Implemention of textDocument/hover as described in LSP definition.
This patch adds a basic Hover implementation. When hovering a variable,
function, method or namespace, clangd will return a text containing the
declaration's scope, as well as the declaration of the hovered entity.
For example, for a variable:
Declared in class Foo::Bar
int hello = 2
For macros, the macro definition is returned.
This patch doesn't include:
- markdown support (the client I use doesn't support it yet)
- range support (optional in the Hover response)
- comments associated to variables/functions/classes
They are kept as future work to keep this patch simpler.
I added tests in XRefsTests.cpp. hover.test contains one simple
smoketest to make sure the feature works from a black box perspective.
Reviewers: malaperle, krasimir, bkramer, ilya-biryukov
Subscribers: sammccall, mgrang, klimek, rwols, ilya-biryukov, arphaman, cfe-commits
Differential Revision: https://reviews.llvm.org/D35894
Signed-off-by: Simon Marchi <simon.marchi@ericsson.com>
Signed-off-by: William Enright <william.enright@polymtl.ca>
llvm-svn: 325395
2018-02-17 05:38:15 +08:00
|
|
|
return H;
|
|
|
|
}
|
|
|
|
|
2018-07-03 00:28:34 +08:00
|
|
|
/// Generate a \p Hover object given the type \p T.
|
|
|
|
static Hover getHoverContents(QualType T, ASTContext &ASTCtx) {
|
|
|
|
Hover H;
|
|
|
|
std::string TypeText;
|
|
|
|
llvm::raw_string_ostream OS(TypeText);
|
2018-07-26 20:05:31 +08:00
|
|
|
PrintingPolicy Policy = printingPolicyForDecls(ASTCtx.getPrintingPolicy());
|
2018-07-03 00:28:34 +08:00
|
|
|
T.print(OS, Policy);
|
|
|
|
OS.flush();
|
|
|
|
H.contents.value += TypeText;
|
|
|
|
return H;
|
|
|
|
}
|
|
|
|
|
[clangd] Implement textDocument/hover
Summary: Implemention of textDocument/hover as described in LSP definition.
This patch adds a basic Hover implementation. When hovering a variable,
function, method or namespace, clangd will return a text containing the
declaration's scope, as well as the declaration of the hovered entity.
For example, for a variable:
Declared in class Foo::Bar
int hello = 2
For macros, the macro definition is returned.
This patch doesn't include:
- markdown support (the client I use doesn't support it yet)
- range support (optional in the Hover response)
- comments associated to variables/functions/classes
They are kept as future work to keep this patch simpler.
I added tests in XRefsTests.cpp. hover.test contains one simple
smoketest to make sure the feature works from a black box perspective.
Reviewers: malaperle, krasimir, bkramer, ilya-biryukov
Subscribers: sammccall, mgrang, klimek, rwols, ilya-biryukov, arphaman, cfe-commits
Differential Revision: https://reviews.llvm.org/D35894
Signed-off-by: Simon Marchi <simon.marchi@ericsson.com>
Signed-off-by: William Enright <william.enright@polymtl.ca>
llvm-svn: 325395
2018-02-17 05:38:15 +08:00
|
|
|
/// Generate a \p Hover object given the macro \p MacroInf.
|
|
|
|
static Hover getHoverContents(StringRef MacroName) {
|
|
|
|
Hover H;
|
|
|
|
|
2018-02-17 07:12:26 +08:00
|
|
|
H.contents.value = "#define ";
|
|
|
|
H.contents.value += MacroName;
|
[clangd] Implement textDocument/hover
Summary: Implemention of textDocument/hover as described in LSP definition.
This patch adds a basic Hover implementation. When hovering a variable,
function, method or namespace, clangd will return a text containing the
declaration's scope, as well as the declaration of the hovered entity.
For example, for a variable:
Declared in class Foo::Bar
int hello = 2
For macros, the macro definition is returned.
This patch doesn't include:
- markdown support (the client I use doesn't support it yet)
- range support (optional in the Hover response)
- comments associated to variables/functions/classes
They are kept as future work to keep this patch simpler.
I added tests in XRefsTests.cpp. hover.test contains one simple
smoketest to make sure the feature works from a black box perspective.
Reviewers: malaperle, krasimir, bkramer, ilya-biryukov
Subscribers: sammccall, mgrang, klimek, rwols, ilya-biryukov, arphaman, cfe-commits
Differential Revision: https://reviews.llvm.org/D35894
Signed-off-by: Simon Marchi <simon.marchi@ericsson.com>
Signed-off-by: William Enright <william.enright@polymtl.ca>
llvm-svn: 325395
2018-02-17 05:38:15 +08:00
|
|
|
|
|
|
|
return H;
|
|
|
|
}
|
|
|
|
|
2018-07-03 00:28:34 +08:00
|
|
|
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;
|
|
|
|
llvm::Optional<QualType> DeducedType;
|
|
|
|
|
|
|
|
public:
|
|
|
|
DeducedTypeVisitor(SourceLocation SearchedLocation)
|
|
|
|
: SearchedLocation(SearchedLocation) {}
|
|
|
|
|
|
|
|
llvm::Optional<QualType> getDeducedType() { return DeducedType; }
|
|
|
|
|
|
|
|
// Handle auto initializers:
|
|
|
|
//- auto i = 1;
|
|
|
|
//- decltype(auto) i = 1;
|
|
|
|
//- auto& i = 1;
|
|
|
|
bool VisitDeclaratorDecl(DeclaratorDecl *D) {
|
|
|
|
if (!D->getTypeSourceInfo() ||
|
2018-08-10 06:42:26 +08:00
|
|
|
D->getTypeSourceInfo()->getTypeLoc().getBeginLoc() != SearchedLocation)
|
2018-07-03 00:28:34 +08:00
|
|
|
return true;
|
|
|
|
|
|
|
|
auto DeclT = D->getType();
|
|
|
|
// "auto &" is represented as a ReferenceType containing an AutoType
|
|
|
|
if (const ReferenceType *RT = dyn_cast<ReferenceType>(DeclT.getTypePtr()))
|
|
|
|
DeclT = RT->getPointeeType();
|
|
|
|
|
|
|
|
const AutoType *AT = dyn_cast<AutoType>(DeclT.getTypePtr());
|
|
|
|
if (AT && !AT->getDeducedType().isNull()) {
|
|
|
|
// For auto, use the underlying type because the const& would be
|
|
|
|
// represented twice: written in the code and in the hover.
|
|
|
|
// Example: "const auto I = 1", we only want "int" when hovering on auto,
|
|
|
|
// not "const int".
|
|
|
|
//
|
|
|
|
// For decltype(auto), take the type as is because it cannot be written
|
|
|
|
// with qualifiers or references but its decuded type can be const-ref.
|
|
|
|
DeducedType = AT->isDecltypeAuto() ? DeclT : DeclT.getUnqualifiedType();
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Handle auto return types:
|
|
|
|
//- auto foo() {}
|
|
|
|
//- auto& foo() {}
|
|
|
|
//- 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;
|
|
|
|
|
|
|
|
auto T = D->getReturnType();
|
|
|
|
// "auto &" is represented as a ReferenceType containing an AutoType.
|
|
|
|
if (const ReferenceType *RT = dyn_cast<ReferenceType>(T.getTypePtr()))
|
|
|
|
T = RT->getPointeeType();
|
|
|
|
|
|
|
|
const AutoType *AT = dyn_cast<AutoType>(T.getTypePtr());
|
|
|
|
if (AT && !AT->getDeducedType().isNull()) {
|
|
|
|
DeducedType = T.getUnqualifiedType();
|
|
|
|
} else { // auto in a trailing return type just points to a DecltypeType.
|
|
|
|
const DecltypeType *DT = dyn_cast<DecltypeType>(T.getTypePtr());
|
|
|
|
if (!DT->getUnderlyingType().isNull())
|
|
|
|
DeducedType = DT->getUnderlyingType();
|
|
|
|
}
|
|
|
|
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();
|
|
|
|
DT = dyn_cast<DecltypeType>(DeducedType->getTypePtr());
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
} // namespace
|
|
|
|
|
|
|
|
/// Retrieves the deduced type at a given location (auto, decltype).
|
|
|
|
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);
|
|
|
|
for (Decl *D : AST.getLocalTopLevelDecls())
|
|
|
|
V.TraverseDecl(D);
|
|
|
|
return V.getDeducedType();
|
|
|
|
}
|
|
|
|
|
2018-06-04 18:37:16 +08:00
|
|
|
Optional<Hover> getHover(ParsedAST &AST, Position Pos) {
|
[clangd] Implement textDocument/hover
Summary: Implemention of textDocument/hover as described in LSP definition.
This patch adds a basic Hover implementation. When hovering a variable,
function, method or namespace, clangd will return a text containing the
declaration's scope, as well as the declaration of the hovered entity.
For example, for a variable:
Declared in class Foo::Bar
int hello = 2
For macros, the macro definition is returned.
This patch doesn't include:
- markdown support (the client I use doesn't support it yet)
- range support (optional in the Hover response)
- comments associated to variables/functions/classes
They are kept as future work to keep this patch simpler.
I added tests in XRefsTests.cpp. hover.test contains one simple
smoketest to make sure the feature works from a black box perspective.
Reviewers: malaperle, krasimir, bkramer, ilya-biryukov
Subscribers: sammccall, mgrang, klimek, rwols, ilya-biryukov, arphaman, cfe-commits
Differential Revision: https://reviews.llvm.org/D35894
Signed-off-by: Simon Marchi <simon.marchi@ericsson.com>
Signed-off-by: William Enright <william.enright@polymtl.ca>
llvm-svn: 325395
2018-02-17 05:38:15 +08:00
|
|
|
const SourceManager &SourceMgr = AST.getASTContext().getSourceManager();
|
[clangd] Fix unicode handling, using UTF-16 where LSP requires it.
Summary:
The Language Server Protocol unfortunately mandates that locations in files
be represented by line/column pairs, where the "column" is actually an index
into the UTF-16-encoded text of the line.
(This is because VSCode is written in JavaScript, which is UTF-16-native).
Internally clangd treats source files at UTF-8, the One True Encoding, and
generally deals with byte offsets (though there are exceptions).
Before this patch, conversions between offsets and LSP Position pretended
that Position.character was UTF-8 bytes, which is only true for ASCII lines.
Now we examine the text to convert correctly (but don't actually need to
transcode it, due to some nice details of the encodings).
The updated functions in SourceCode are the blessed way to interact with
the Position.character field, and anything else is likely to be wrong.
So I also updated the other accesses:
- CodeComplete needs a "clang-style" line/column, with column in utf-8 bytes.
This is now converted via Position -> offset -> clang line/column
(a new function is added to SourceCode.h for the second conversion).
- getBeginningOfIdentifier skipped backwards in UTF-16 space, which is will
behave badly when it splits a surrogate pair. Skipping backwards in UTF-8
coordinates gives the lexer a fighting chance of getting this right.
While here, I clarified(?) the logic comments, fixed a bug with identifiers
containing digits, simplified the signature slightly and added a test.
This seems likely to cause problems with editors that have the same bug, and
treat the protocol as if columns are UTF-8 bytes. But we can find and fix those.
Reviewers: hokein
Subscribers: klimek, ilya-biryukov, ioeric, MaskRay, jkorous, cfe-commits
Differential Revision: https://reviews.llvm.org/D46035
llvm-svn: 331029
2018-04-27 19:59:28 +08:00
|
|
|
SourceLocation SourceLocationBeg =
|
|
|
|
getBeginningOfIdentifier(AST, Pos, SourceMgr.getMainFileID());
|
2018-04-30 23:24:17 +08:00
|
|
|
// Identified symbols at a specific position.
|
|
|
|
auto Symbols = getSymbolAtPosition(AST, SourceLocationBeg);
|
[clangd] Implement textDocument/hover
Summary: Implemention of textDocument/hover as described in LSP definition.
This patch adds a basic Hover implementation. When hovering a variable,
function, method or namespace, clangd will return a text containing the
declaration's scope, as well as the declaration of the hovered entity.
For example, for a variable:
Declared in class Foo::Bar
int hello = 2
For macros, the macro definition is returned.
This patch doesn't include:
- markdown support (the client I use doesn't support it yet)
- range support (optional in the Hover response)
- comments associated to variables/functions/classes
They are kept as future work to keep this patch simpler.
I added tests in XRefsTests.cpp. hover.test contains one simple
smoketest to make sure the feature works from a black box perspective.
Reviewers: malaperle, krasimir, bkramer, ilya-biryukov
Subscribers: sammccall, mgrang, klimek, rwols, ilya-biryukov, arphaman, cfe-commits
Differential Revision: https://reviews.llvm.org/D35894
Signed-off-by: Simon Marchi <simon.marchi@ericsson.com>
Signed-off-by: William Enright <william.enright@polymtl.ca>
llvm-svn: 325395
2018-02-17 05:38:15 +08:00
|
|
|
|
2018-04-30 23:24:17 +08:00
|
|
|
if (!Symbols.Macros.empty())
|
|
|
|
return getHoverContents(Symbols.Macros[0].Name);
|
[clangd] Implement textDocument/hover
Summary: Implemention of textDocument/hover as described in LSP definition.
This patch adds a basic Hover implementation. When hovering a variable,
function, method or namespace, clangd will return a text containing the
declaration's scope, as well as the declaration of the hovered entity.
For example, for a variable:
Declared in class Foo::Bar
int hello = 2
For macros, the macro definition is returned.
This patch doesn't include:
- markdown support (the client I use doesn't support it yet)
- range support (optional in the Hover response)
- comments associated to variables/functions/classes
They are kept as future work to keep this patch simpler.
I added tests in XRefsTests.cpp. hover.test contains one simple
smoketest to make sure the feature works from a black box perspective.
Reviewers: malaperle, krasimir, bkramer, ilya-biryukov
Subscribers: sammccall, mgrang, klimek, rwols, ilya-biryukov, arphaman, cfe-commits
Differential Revision: https://reviews.llvm.org/D35894
Signed-off-by: Simon Marchi <simon.marchi@ericsson.com>
Signed-off-by: William Enright <william.enright@polymtl.ca>
llvm-svn: 325395
2018-02-17 05:38:15 +08:00
|
|
|
|
2018-04-30 23:24:17 +08:00
|
|
|
if (!Symbols.Decls.empty())
|
|
|
|
return getHoverContents(Symbols.Decls[0]);
|
[clangd] Implement textDocument/hover
Summary: Implemention of textDocument/hover as described in LSP definition.
This patch adds a basic Hover implementation. When hovering a variable,
function, method or namespace, clangd will return a text containing the
declaration's scope, as well as the declaration of the hovered entity.
For example, for a variable:
Declared in class Foo::Bar
int hello = 2
For macros, the macro definition is returned.
This patch doesn't include:
- markdown support (the client I use doesn't support it yet)
- range support (optional in the Hover response)
- comments associated to variables/functions/classes
They are kept as future work to keep this patch simpler.
I added tests in XRefsTests.cpp. hover.test contains one simple
smoketest to make sure the feature works from a black box perspective.
Reviewers: malaperle, krasimir, bkramer, ilya-biryukov
Subscribers: sammccall, mgrang, klimek, rwols, ilya-biryukov, arphaman, cfe-commits
Differential Revision: https://reviews.llvm.org/D35894
Signed-off-by: Simon Marchi <simon.marchi@ericsson.com>
Signed-off-by: William Enright <william.enright@polymtl.ca>
llvm-svn: 325395
2018-02-17 05:38:15 +08:00
|
|
|
|
2018-07-03 00:28:34 +08:00
|
|
|
auto DeducedType = getDeducedType(AST, SourceLocationBeg);
|
|
|
|
if (DeducedType && !DeducedType->isNull())
|
|
|
|
return getHoverContents(*DeducedType, AST.getASTContext());
|
|
|
|
|
2018-06-04 18:37:16 +08:00
|
|
|
return None;
|
[clangd] Implement textDocument/hover
Summary: Implemention of textDocument/hover as described in LSP definition.
This patch adds a basic Hover implementation. When hovering a variable,
function, method or namespace, clangd will return a text containing the
declaration's scope, as well as the declaration of the hovered entity.
For example, for a variable:
Declared in class Foo::Bar
int hello = 2
For macros, the macro definition is returned.
This patch doesn't include:
- markdown support (the client I use doesn't support it yet)
- range support (optional in the Hover response)
- comments associated to variables/functions/classes
They are kept as future work to keep this patch simpler.
I added tests in XRefsTests.cpp. hover.test contains one simple
smoketest to make sure the feature works from a black box perspective.
Reviewers: malaperle, krasimir, bkramer, ilya-biryukov
Subscribers: sammccall, mgrang, klimek, rwols, ilya-biryukov, arphaman, cfe-commits
Differential Revision: https://reviews.llvm.org/D35894
Signed-off-by: Simon Marchi <simon.marchi@ericsson.com>
Signed-off-by: William Enright <william.enright@polymtl.ca>
llvm-svn: 325395
2018-02-17 05:38:15 +08:00
|
|
|
}
|
|
|
|
|
2017-12-20 01:06:07 +08:00
|
|
|
} // namespace clangd
|
|
|
|
} // namespace clang
|