Hi Ilya,
This patch doesn't compile for me with clang 3.6.0. I get:
../tools/clang/tools/extra/clangd/Protocol.cpp:474:10: error: no viable
conversion from 'json::Object' to 'llvm::json::Value'
return Result;
^~~~~~
../include/llvm/Support/JSON.h:291:3: note: candidate constructor not
viable: no known conversion from 'json::Object' to 'const
llvm::json::Value &' for 1st argument
Value(const Value &M) { copyFrom(M); }
^
../include/llvm/Support/JSON.h:292:3: note: candidate constructor not
viable: no known conversion from 'json::Object' to 'llvm::json::Value
&&' for 1st argument
Value(Value &&M) { moveFrom(std::move(M)); }
^
../include/llvm/Support/JSON.h:293:3: note: candidate constructor not
viable: no known conversion from 'json::Object' to
'std::initializer_list<Value>' for 1st argument
Value(std::initializer_list<Value> Elements);
^
../include/llvm/Support/JSON.h:294:3: note: candidate constructor not
viable: no known conversion from 'json::Object' to 'json::Array &&' for
1st argument
Value(json::Array &&Elements) : Type(T_Array) {
^
../include/llvm/Support/JSON.h:299:3: note: candidate constructor not
viable: no known conversion from 'json::Object' to 'json::Object &&' for
1st argument
Value(json::Object &&Properties) : Type(T_Object) {
^
../include/llvm/Support/JSON.h:305:3: note: candidate constructor not
viable: no known conversion from 'json::Object' to 'std::string' (aka
'basic_string<char>') for 1st argument
Value(std::string V) : Type(T_String) {
^
../include/llvm/Support/JSON.h:312:3: note: candidate constructor not
viable: no known conversion from 'json::Object' to 'const
llvm::SmallVectorImpl<char> &' for 1st argument
Value(const llvm::SmallVectorImpl<char> &V)
^
../include/llvm/Support/JSON.h:314:3: note: candidate constructor not
viable: no known conversion from 'json::Object' to 'const
llvm::formatv_object_base &' for 1st argument
Value(const llvm::formatv_object_base &V) : Value(V.str()){};
^
../include/llvm/Support/JSON.h:316:3: note: candidate constructor not
viable: no known conversion from 'json::Object' to 'llvm::StringRef' for
1st argument
Value(StringRef V) : Type(T_StringRef) {
^
../include/llvm/Support/JSON.h:323:3: note: candidate constructor not
viable: no known conversion from 'json::Object' to 'const char *' for
1st argument
Value(const char *V) : Value(StringRef(V)) {}
^
../include/llvm/Support/JSON.h:324:3: note: candidate constructor not
viable: no known conversion from 'json::Object' to 'std::nullptr_t' (aka
'nullptr_t') for 1st argument
Value(std::nullptr_t) : Type(T_Null) {}
^
../include/llvm/Support/JSON.h:298:3: note: candidate template ignored:
could not match 'vector<type-parameter-0-0,
allocator<type-parameter-0-0> >' against 'llvm::json::Object'
Value(const std::vector<Elt> &C) : Value(json::Array(C)) {}
^
../include/llvm/Support/JSON.h:303:3: note: candidate template ignored:
could not match 'map<std::basic_string<char>, type-parameter-0-0,
std::less<std::basic_string<char> >, allocator<pair<const
std::basic_string<char>, type-parameter-0-0> > >' against
'llvm::json::Object'
Value(const std::map<std::string, Elt> &C) : Value(json::Object(C)) {}
^
../include/llvm/Support/JSON.h:329:42: note: candidate template ignored:
disabled by 'enable_if' [with T = llvm::json::Object]
typename = typename std::enable_if<std::is_same<T,
bool>::value>::type,
^
../include/llvm/Support/JSON.h:337:42: note: candidate template ignored:
disabled by 'enable_if' [with T = llvm::json::Object]
typename = typename std::enable_if<std::is_integral<T>::value>::type,
^
../include/llvm/Support/JSON.h:345:41: note: candidate template ignored:
disabled by 'enable_if' [with T = llvm::json::Object]
typename
std::enable_if<std::is_floating_point<T>::value>::type,
^
../include/llvm/Support/JSON.h:355:3: note: candidate template ignored:
substitution failure [with T = llvm::json::Object]: no matching function
for call to 'toJSON'
Value(const T &V) : Value(toJSON(V)) {}
^
1 error generated.
ninja: build stopped: subcommand failed.
system(/proj/flexasic/app/ninja/1.8.2/SLED11-64/bin/ninja -j1 -C
build-all all) failed: child exited with value 1
A couple of the build bots fail the same way, see e.g:
http://lab.llvm.org:8011/builders/clang-cmake-armv7-quick/builds/5512/steps/build%20stage%201/logs/stdio
-------------
This patch also causes a couple of new warnings:
../tools/clang/tools/extra/clangd/AST.cpp:98:13: error: unused variable
'NS' [-Werror,-Wunused-variable]
if (auto *NS = llvm::dyn_cast<NamespaceDecl>(&ND))
^
../tools/clang/tools/extra/clangd/AST.cpp:102:13: error: unused variable
'En' [-Werror,-Wunused-variable]
if (auto *En = llvm::dyn_cast<EnumDecl>(&ND))
^
2 errors generated.
/Mikael
On 11/23/18 4:21 PM, Ilya Biryukov via cfe-commits wrote:
> Author: ibiryukov
> Date: Fri Nov 23 07:21:19 2018
> New Revision: 347498
>
> URL: http://llvm.org/viewvc/llvm-project?rev=347498&view=rev
> Log:
> [clangd] Add support for hierarchical documentSymbol
>
> Reviewers: ioeric, sammccall, simark
>
> Reviewed By: sammccall
>
> Subscribers: MaskRay, jkorous, arphaman, kadircet, cfe-commits
>
> Differential Revision: https://reviews.llvm.org/D52311
>
> Modified:
> clang-tools-extra/trunk/clangd/AST.cpp
> clang-tools-extra/trunk/clangd/AST.h
> clang-tools-extra/trunk/clangd/ClangdLSPServer.cpp
> clang-tools-extra/trunk/clangd/ClangdLSPServer.h
> clang-tools-extra/trunk/clangd/ClangdServer.cpp
> clang-tools-extra/trunk/clangd/ClangdServer.h
> clang-tools-extra/trunk/clangd/FindSymbols.cpp
> clang-tools-extra/trunk/clangd/FindSymbols.h
> clang-tools-extra/trunk/clangd/Protocol.cpp
> clang-tools-extra/trunk/clangd/Protocol.h
> clang-tools-extra/trunk/clangd/clients/clangd-vscode/package.json
> clang-tools-extra/trunk/unittests/clangd/FindSymbolsTests.cpp
> clang-tools-extra/trunk/unittests/clangd/SyncAPI.cpp
> clang-tools-extra/trunk/unittests/clangd/SyncAPI.h
>
> Modified: clang-tools-extra/trunk/clangd/AST.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/clangd/AST.cpp?rev=347498&r1=347497&r2=347498&view=diff
> ==============================================================================
> --- clang-tools-extra/trunk/clangd/AST.cpp (original)
> +++ clang-tools-extra/trunk/clangd/AST.cpp Fri Nov 23 07:21:19 2018
> @@ -11,9 +11,12 @@
>
> #include "clang/AST/ASTContext.h"
> #include "clang/AST/Decl.h"
> +#include "clang/AST/DeclTemplate.h"
> #include "clang/Basic/SourceLocation.h"
> #include "clang/Basic/SourceManager.h"
> #include "clang/Index/USRGeneration.h"
> +#include "llvm/Support/Casting.h"
> +#include "llvm/Support/ScopedPrinter.h"
>
> using namespace llvm;
> namespace clang {
> @@ -61,6 +64,46 @@ std::string printQualifiedName(const Nam
> return QName;
> }
>
> +static const TemplateArgumentList *
> +getTemplateSpecializationArgs(const NamedDecl &ND) {
> + if (auto *Func = llvm::dyn_cast<FunctionDecl>(&ND))
> + return Func->getTemplateSpecializationArgs();
> + if (auto *Cls = llvm::dyn_cast<ClassTemplateSpecializationDecl>(&ND))
> + return &Cls->getTemplateInstantiationArgs();
> + if (auto *Var = llvm::dyn_cast<VarTemplateSpecializationDecl>(&ND))
> + return &Var->getTemplateInstantiationArgs();
> + return nullptr;
> +}
> +
> +std::string printName(const ASTContext &Ctx, const NamedDecl &ND) {
> + std::string Name;
> + llvm::raw_string_ostream Out(Name);
> + PrintingPolicy PP(Ctx.getLangOpts());
> + // Handle 'using namespace'. They all have the same name -
> <using-directive>.
> + if (auto *UD = llvm::dyn_cast<UsingDirectiveDecl>(&ND)) {
> + Out << "using namespace ";
> + if (auto *Qual = UD->getQualifier())
> + Qual->print(Out, PP);
> + UD->getNominatedNamespaceAsWritten()->printName(Out);
> + return Out.str();
> + }
> + ND.getDeclName().print(Out, PP);
> + if (!Out.str().empty()) {
> + // FIXME(ibiryukov): do not show args not explicitly written by the user.
> + if (auto *ArgList = getTemplateSpecializationArgs(ND))
> + printTemplateArgumentList(Out, ArgList->asArray(), PP);
> + return Out.str();
> + }
> + // The name was empty, so present an anonymous entity.
> + if (auto *NS = llvm::dyn_cast<NamespaceDecl>(&ND))
> + return "(anonymous namespace)";
> + if (auto *Cls = llvm::dyn_cast<RecordDecl>(&ND))
> + return ("(anonymous " + Cls->getKindName() + ")").str();
> + if (auto *En = llvm::dyn_cast<EnumDecl>(&ND))
> + return "(anonymous enum)";
> + return "(anonymous)";
> +}
> +
> std::string printNamespaceScope(const DeclContext &DC) {
> for (const auto *Ctx = &DC; Ctx != nullptr; Ctx = Ctx->getParent())
> if (const auto *NS = dyn_cast<NamespaceDecl>(Ctx))
>
> Modified: clang-tools-extra/trunk/clangd/AST.h
> URL:
> http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/clangd/AST.h?rev=347498&r1=347497&r2=347498&view=diff
> ==============================================================================
> --- clang-tools-extra/trunk/clangd/AST.h (original)
> +++ clang-tools-extra/trunk/clangd/AST.h Fri Nov 23 07:21:19 2018
> @@ -42,6 +42,11 @@ std::string printQualifiedName(const Nam
> /// Returns the first enclosing namespace scope starting from \p DC.
> std::string printNamespaceScope(const DeclContext &DC);
>
> +/// Prints unqualified name of the decl for the purpose of displaying it to
> the
> +/// user. Anonymous decls return names of the form "(anonymous {kind})", e.g.
> +/// "(anonymous struct)" or "(anonymous namespace)".
> +std::string printName(const ASTContext &Ctx, const NamedDecl &ND);
> +
> /// Gets the symbol ID for a declaration, if possible.
> llvm::Optional<SymbolID> getSymbolID(const Decl *D);
>
>
> Modified: clang-tools-extra/trunk/clangd/ClangdLSPServer.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/clangd/ClangdLSPServer.cpp?rev=347498&r1=347497&r2=347498&view=diff
> ==============================================================================
> --- clang-tools-extra/trunk/clangd/ClangdLSPServer.cpp (original)
> +++ clang-tools-extra/trunk/clangd/ClangdLSPServer.cpp Fri Nov 23 07:21:19
> 2018
> @@ -23,6 +23,14 @@ namespace clang {
> namespace clangd {
> namespace {
>
> +void adjustSymbolKinds(llvm::MutableArrayRef<DocumentSymbol> Syms,
> + SymbolKindBitset Kinds) {
> + for (auto &S : Syms) {
> + S.kind = adjustKindToCapability(S.kind, Kinds);
> + adjustSymbolKinds(S.children, Kinds);
> + }
> +}
> +
> SymbolKindBitset defaultSymbolKinds() {
> SymbolKindBitset Defaults;
> for (size_t I = SymbolKindMin; I <=
> static_cast<size_t>(SymbolKind::Array);
> @@ -284,6 +292,8 @@ void ClangdLSPServer::onInitialize(const
> if (Params.capabilities.CompletionItemKinds)
> SupportedCompletionItemKinds |=
> *Params.capabilities.CompletionItemKinds;
> SupportsCodeAction = Params.capabilities.CodeActionStructure;
> + SupportsHierarchicalDocumentSymbol =
> + Params.capabilities.HierarchicalDocumentSymbol;
>
> Reply(json::Object{
> {{"capabilities",
> @@ -501,19 +511,48 @@ void ClangdLSPServer::onDocumentFormatti
> Reply(ReplacementsOrError.takeError());
> }
>
> -void ClangdLSPServer::onDocumentSymbol(
> - const DocumentSymbolParams &Params,
> - Callback<std::vector<SymbolInformation>> Reply) {
> +/// The functions constructs a flattened view of the DocumentSymbol
> hierarchy.
> +/// Used by the clients that do not support the hierarchical view.
> +static std::vector<SymbolInformation>
> +flattenSymbolHierarchy(llvm::ArrayRef<DocumentSymbol> Symbols,
> + const URIForFile &FileURI) {
> +
> + std::vector<SymbolInformation> Results;
> + std::function<void(const DocumentSymbol &, StringRef)> Process =
> + [&](const DocumentSymbol &S, Optional<StringRef> ParentName) {
> + SymbolInformation SI;
> + SI.containerName = ParentName ? "" : *ParentName;
> + SI.name = S.name;
> + SI.kind = S.kind;
> + SI.location.range = S.range;
> + SI.location.uri = FileURI;
> +
> + Results.push_back(std::move(SI));
> + std::string FullName =
> + !ParentName ? S.name : (ParentName->str() + "::" + S.name);
> + for (auto &C : S.children)
> + Process(C, /*ParentName=*/FullName);
> + };
> + for (auto &S : Symbols)
> + Process(S, /*ParentName=*/"");
> + return Results;
> +}
> +
> +void ClangdLSPServer::onDocumentSymbol(const DocumentSymbolParams &Params,
> + Callback<json::Value> Reply) {
> + URIForFile FileURI = Params.textDocument.uri;
> Server->documentSymbols(
> Params.textDocument.uri.file(),
> Bind(
> - [this](decltype(Reply) Reply,
> - Expected<std::vector<SymbolInformation>> Items) {
> + [this, FileURI](decltype(Reply) Reply,
> + Expected<std::vector<DocumentSymbol>> Items) {
> if (!Items)
> return Reply(Items.takeError());
> - for (auto &Sym : *Items)
> - Sym.kind = adjustKindToCapability(Sym.kind,
> SupportedSymbolKinds);
> - Reply(std::move(*Items));
> + adjustSymbolKinds(*Items, SupportedSymbolKinds);
> + if (SupportsHierarchicalDocumentSymbol)
> + return Reply(std::move(*Items));
> + else
> + return Reply(flattenSymbolHierarchy(*Items, FileURI));
> },
> std::move(Reply)));
> }
>
> Modified: clang-tools-extra/trunk/clangd/ClangdLSPServer.h
> URL:
> http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/clangd/ClangdLSPServer.h?rev=347498&r1=347497&r2=347498&view=diff
> ==============================================================================
> --- clang-tools-extra/trunk/clangd/ClangdLSPServer.h (original)
> +++ clang-tools-extra/trunk/clangd/ClangdLSPServer.h Fri Nov 23 07:21:19 2018
> @@ -66,8 +66,11 @@ private:
> Callback<std::vector<TextEdit>>);
> void onDocumentFormatting(const DocumentFormattingParams &,
> Callback<std::vector<TextEdit>>);
> + // The results are serialized 'vector<DocumentSymbol>' if
> + // SupportsHierarchicalDocumentSymbol is true and
> 'vector<SymbolInformation>'
> + // otherwise.
> void onDocumentSymbol(const DocumentSymbolParams &,
> - Callback<std::vector<SymbolInformation>>);
> + Callback<llvm::json::Value>);
> void onCodeAction(const CodeActionParams &, Callback<llvm::json::Value>);
> void onCompletion(const TextDocumentPositionParams &,
> Callback<CompletionList>);
> @@ -128,6 +131,8 @@ private:
> CompletionItemKindBitset SupportedCompletionItemKinds;
> // Whether the client supports CodeAction response objects.
> bool SupportsCodeAction = false;
> + /// From capabilities of textDocument/documentSymbol.
> + bool SupportsHierarchicalDocumentSymbol = false;
>
> // Store of the current versions of the open documents.
> DraftStore DraftMgr;
>
> Modified: clang-tools-extra/trunk/clangd/ClangdServer.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/clangd/ClangdServer.cpp?rev=347498&r1=347497&r2=347498&view=diff
> ==============================================================================
> --- clang-tools-extra/trunk/clangd/ClangdServer.cpp (original)
> +++ clang-tools-extra/trunk/clangd/ClangdServer.cpp Fri Nov 23 07:21:19 2018
> @@ -470,10 +470,10 @@ void ClangdServer::workspaceSymbols(
> std::move(CB)));
> }
>
> -void ClangdServer::documentSymbols(
> - StringRef File, Callback<std::vector<SymbolInformation>> CB) {
> - auto Action = [](Callback<std::vector<SymbolInformation>> CB,
> - Expected<InputsAndAST> InpAST) {
> +void ClangdServer::documentSymbols(StringRef File,
> + Callback<std::vector<DocumentSymbol>> CB)
> {
> + auto Action = [](Callback<std::vector<DocumentSymbol>> CB,
> + llvm::Expected<InputsAndAST> InpAST) {
> if (!InpAST)
> return CB(InpAST.takeError());
> CB(clangd::getDocumentSymbols(InpAST->AST));
>
> Modified: clang-tools-extra/trunk/clangd/ClangdServer.h
> URL:
> http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/clangd/ClangdServer.h?rev=347498&r1=347497&r2=347498&view=diff
> ==============================================================================
> --- clang-tools-extra/trunk/clangd/ClangdServer.h (original)
> +++ clang-tools-extra/trunk/clangd/ClangdServer.h Fri Nov 23 07:21:19 2018
> @@ -167,7 +167,7 @@ public:
>
> /// Retrieve the symbols within the specified file.
> void documentSymbols(StringRef File,
> - Callback<std::vector<SymbolInformation>> CB);
> + Callback<std::vector<DocumentSymbol>> CB);
>
> /// Retrieve locations for symbol references.
> void findReferences(PathRef File, Position Pos,
>
> Modified: clang-tools-extra/trunk/clangd/FindSymbols.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/clangd/FindSymbols.cpp?rev=347498&r1=347497&r2=347498&view=diff
> ==============================================================================
> --- clang-tools-extra/trunk/clangd/FindSymbols.cpp (original)
> +++ clang-tools-extra/trunk/clangd/FindSymbols.cpp Fri Nov 23 07:21:19 2018
> @@ -15,11 +15,13 @@
> #include "Quality.h"
> #include "SourceCode.h"
> #include "index/Index.h"
> +#include "clang/AST/DeclTemplate.h"
> #include "clang/Index/IndexDataConsumer.h"
> #include "clang/Index/IndexSymbol.h"
> #include "clang/Index/IndexingAction.h"
> #include "llvm/Support/FormatVariadic.h"
> #include "llvm/Support/Path.h"
> +#include "llvm/Support/ScopedPrinter.h"
>
> #define DEBUG_TYPE "FindSymbols"
>
> @@ -178,104 +180,146 @@ getWorkspaceSymbols(StringRef Query, int
> }
>
> namespace {
> -/// Finds document symbols in the main file of the AST.
> -class DocumentSymbolsConsumer : public index::IndexDataConsumer {
> - ASTContext &AST;
> - std::vector<SymbolInformation> Symbols;
> - // We are always list document for the same file, so cache the value.
> - Optional<URIForFile> MainFileUri;
> +llvm::Optional<DocumentSymbol> declToSym(ASTContext &Ctx, const NamedDecl
> &ND) {
> + auto &SM = Ctx.getSourceManager();
>
> + SourceLocation NameLoc = findNameLoc(&ND);
> + // 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;
> +
> + if (!SM.isWrittenInMainFile(NameLoc) || !SM.isWrittenInMainFile(BeginLoc)
> ||
> + !SM.isWrittenInMainFile(EndLoc))
> + 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);
> +
> + DocumentSymbol SI;
> + SI.name = printName(Ctx, ND);
> + SI.kind = SK;
> + SI.deprecated = ND.isDeprecated();
> + SI.range =
> + Range{sourceLocToPosition(SM, BeginLoc), sourceLocToPosition(SM,
> EndLoc)};
> + SI.selectionRange = Range{NameBegin, NameEnd};
> + if (!SI.range.contains(SI.selectionRange)) {
> + // 'selectionRange' must be contained in 'range', so in cases where clang
> + // reports unrelated ranges we need to reconcile somehow.
> + SI.range = SI.selectionRange;
> + }
> + return SI;
> +}
> +
> +/// A helper class to build an outline for the parse AST. It traverse the AST
> +/// directly instead of using RecursiveASTVisitor (RAV) for three main
> reasons:
> +/// - there is no way to keep RAV from traversing subtrees we're not
> +/// interested in. E.g. not traversing function locals or implicit
> template
> +/// instantiations.
> +/// - it's easier to combine results of recursive passes, e.g.
> +/// - visiting decls is actually simple, so we don't hit the complicated
> +/// cases that RAV mostly helps with (types and expressions, etc.)
> +class DocumentOutline {
> public:
> - DocumentSymbolsConsumer(ASTContext &AST) : AST(AST) {}
> - std::vector<SymbolInformation> takeSymbols() { return std::move(Symbols); }
> + DocumentOutline(ParsedAST &AST) : AST(AST) {}
> +
> + /// Builds the document outline for the generated AST.
> + std::vector<DocumentSymbol> build() {
> + std::vector<DocumentSymbol> Results;
> + for (auto &TopLevel : AST.getLocalTopLevelDecls())
> + traverseDecl(TopLevel, Results);
> + return Results;
> + }
>
> - void initialize(ASTContext &Ctx) override {
> - // Compute the absolute path of the main file which we will use for all
> - // results.
> - const SourceManager &SM = AST.getSourceManager();
> - const FileEntry *F = SM.getFileEntryForID(SM.getMainFileID());
> - if (!F)
> +private:
> + enum class VisitKind { No, OnlyDecl, DeclAndChildren };
> +
> + void traverseDecl(Decl *D, std::vector<DocumentSymbol> &Results) {
> + if (auto *Templ = llvm::dyn_cast<TemplateDecl>(D))
> + D = Templ->getTemplatedDecl();
> + auto *ND = llvm::dyn_cast<NamedDecl>(D);
> + if (!ND)
> + return;
> + VisitKind Visit = shouldVisit(ND);
> + if (Visit == VisitKind::No)
> return;
> - auto FilePath = getRealPath(F, SM);
> - if (FilePath)
> - MainFileUri = URIForFile(*FilePath);
> + llvm::Optional<DocumentSymbol> Sym = declToSym(AST.getASTContext(), *ND);
> + if (!Sym)
> + return;
> + if (Visit == VisitKind::DeclAndChildren)
> + traverseChildren(D, Sym->children);
> + Results.push_back(std::move(*Sym));
> }
>
> - bool shouldIncludeSymbol(const NamedDecl *ND) {
> - if (!ND || ND->isImplicit())
> - return false;
> - // Skip anonymous declarations, e.g (anonymous enum/class/struct).
> - if (ND->getDeclName().isEmpty())
> - return false;
> - return true;
> + void traverseChildren(Decl *D, std::vector<DocumentSymbol> &Results) {
> + auto *Scope = llvm::dyn_cast<DeclContext>(D);
> + if (!Scope)
> + return;
> + for (auto *C : Scope->decls())
> + traverseDecl(C, Results);
> }
>
> - bool
> - handleDeclOccurence(const Decl *, index::SymbolRoleSet Roles,
> - ArrayRef<index::SymbolRelation> Relations,
> - SourceLocation Loc,
> - index::IndexDataConsumer::ASTNodeInfo ASTNode)
> override {
> - assert(ASTNode.OrigD);
> - // No point in continuing the index consumer if we could not get the
> - // absolute path of the main file.
> - if (!MainFileUri)
> - return false;
> - // We only want declarations and definitions, i.e. no references.
> - if (!(Roles & static_cast<unsigned>(index::SymbolRole::Declaration) ||
> - Roles & static_cast<unsigned>(index::SymbolRole::Definition)))
> - return true;
> - SourceLocation NameLoc = findNameLoc(ASTNode.OrigD);
> - const SourceManager &SourceMgr = AST.getSourceManager();
> - // We should be only be looking at "local" decls in the main file.
> - if (!SourceMgr.isWrittenInMainFile(NameLoc)) {
> - // Even thought we are visiting only local (non-preamble) decls,
> - // we can get here when in the presence of "extern" decls.
> - return true;
> + VisitKind shouldVisit(NamedDecl *D) {
> + if (D->isImplicit())
> + return VisitKind::No;
> +
> + if (auto Func = llvm::dyn_cast<FunctionDecl>(D)) {
> + // Some functions are implicit template instantiations, those should be
> + // ignored.
> + if (auto *Info = Func->getTemplateSpecializationInfo()) {
> + if (!Info->isExplicitInstantiationOrSpecialization())
> + return VisitKind::No;
> + }
> + // Only visit the function itself, do not visit the children (i.e.
> + // function parameters, etc.)
> + return VisitKind::OnlyDecl;
> }
> - const NamedDecl *ND = dyn_cast<NamedDecl>(ASTNode.OrigD);
> - if (!shouldIncludeSymbol(ND))
> - return true;
> -
> - SourceLocation EndLoc =
> - Lexer::getLocForEndOfToken(NameLoc, 0, SourceMgr, AST.getLangOpts());
> - Position Begin = sourceLocToPosition(SourceMgr, NameLoc);
> - Position End = sourceLocToPosition(SourceMgr, EndLoc);
> - Range R = {Begin, End};
> - Location L;
> - L.uri = *MainFileUri;
> - L.range = R;
> -
> - std::string QName = printQualifiedName(*ND);
> - StringRef Scope, Name;
> - std::tie(Scope, Name) = splitQualifiedName(QName);
> - Scope.consume_back("::");
> -
> - index::SymbolInfo SymInfo = index::getSymbolInfo(ND);
> - SymbolKind SK = indexSymbolKindToSymbolKind(SymInfo.Kind);
> -
> - SymbolInformation SI;
> - SI.name = Name;
> - SI.kind = SK;
> - SI.location = L;
> - SI.containerName = Scope;
> - Symbols.push_back(std::move(SI));
> - return true;
> + // Handle template instantiations. We have three cases to consider:
> + // - explicit instantiations, e.g. 'template class std::vector<int>;'
> + // Visit the decl itself (it's present in the code), but not the
> + // children.
> + // - implicit instantiations, i.e. not written by the user.
> + // Do not visit at all, they are not present in the code.
> + // - explicit specialization, e.g. 'template <> class vector<bool> {};'
> + // Visit both the decl and its children, both are written in the
> code.
> + if (auto *TemplSpec =
> llvm::dyn_cast<ClassTemplateSpecializationDecl>(D)) {
> + if (TemplSpec->isExplicitInstantiationOrSpecialization())
> + return TemplSpec->isExplicitSpecialization()
> + ? VisitKind::DeclAndChildren
> + : VisitKind::OnlyDecl;
> + return VisitKind::No;
> + }
> + if (auto *TemplSpec = llvm::dyn_cast<VarTemplateSpecializationDecl>(D)) {
> + if (TemplSpec->isExplicitInstantiationOrSpecialization())
> + return TemplSpec->isExplicitSpecialization()
> + ? VisitKind::DeclAndChildren
> + : VisitKind::OnlyDecl;
> + return VisitKind::No;
> + }
> + // For all other cases, visit both the children and the decl.
> + return VisitKind::DeclAndChildren;
> }
> -};
> -} // namespace
>
> -Expected<std::vector<SymbolInformation>> getDocumentSymbols(ParsedAST &AST) {
> - DocumentSymbolsConsumer DocumentSymbolsCons(AST.getASTContext());
> + ParsedAST &AST;
> +};
>
> - index::IndexingOptions IndexOpts;
> - IndexOpts.SystemSymbolFilter =
> - index::IndexingOptions::SystemSymbolFilterKind::DeclarationsOnly;
> - IndexOpts.IndexFunctionLocals = false;
> - indexTopLevelDecls(AST.getASTContext(), AST.getPreprocessor(),
> - AST.getLocalTopLevelDecls(), DocumentSymbolsCons,
> - IndexOpts);
> +std::vector<DocumentSymbol> collectDocSymbols(ParsedAST &AST) {
> + return DocumentOutline(AST).build();
> +}
> +} // namespace
>
> - return DocumentSymbolsCons.takeSymbols();
> +llvm::Expected<std::vector<DocumentSymbol>> getDocumentSymbols(ParsedAST
> &AST) {
> + return collectDocSymbols(AST);
> }
>
> } // namespace clangd
>
> Modified: clang-tools-extra/trunk/clangd/FindSymbols.h
> URL:
> http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/clangd/FindSymbols.h?rev=347498&r1=347497&r2=347498&view=diff
> ==============================================================================
> --- clang-tools-extra/trunk/clangd/FindSymbols.h (original)
> +++ clang-tools-extra/trunk/clangd/FindSymbols.h Fri Nov 23 07:21:19 2018
> @@ -36,8 +36,7 @@ getWorkspaceSymbols(llvm::StringRef Quer
>
> /// Retrieves the symbols contained in the "main file" section of an AST in
> the
> /// same order that they appear.
> -llvm::Expected<std::vector<SymbolInformation>>
> -getDocumentSymbols(ParsedAST &AST);
> +llvm::Expected<std::vector<DocumentSymbol>> getDocumentSymbols(ParsedAST
> &AST);
>
> } // namespace clangd
> } // namespace clang
>
> Modified: clang-tools-extra/trunk/clangd/Protocol.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/clangd/Protocol.cpp?rev=347498&r1=347497&r2=347498&view=diff
> ==============================================================================
> --- clang-tools-extra/trunk/clangd/Protocol.cpp (original)
> +++ clang-tools-extra/trunk/clangd/Protocol.cpp Fri Nov 23 07:21:19 2018
> @@ -18,6 +18,7 @@
> #include "llvm/ADT/SmallString.h"
> #include "llvm/Support/Format.h"
> #include "llvm/Support/FormatVariadic.h"
> +#include "llvm/Support/JSON.h"
> #include "llvm/Support/Path.h"
> #include "llvm/Support/raw_ostream.h"
>
> @@ -222,6 +223,11 @@ bool fromJSON(const json::Value &Params,
> if (CodeAction->getObject("codeActionLiteralSupport"))
> R.CodeActionStructure = true;
> }
> + if (auto *DocumentSymbol = TextDocument->getObject("documentSymbol")) {
> + if (auto HierarchicalSupport =
> +
> DocumentSymbol->getBoolean("hierarchicalDocumentSymbolSupport"))
> + R.HierarchicalDocumentSymbol = *HierarchicalSupport;
> + }
> }
> if (auto *Workspace = O->getObject("workspace")) {
> if (auto *Symbol = Workspace->getObject("symbol")) {
> @@ -449,6 +455,25 @@ json::Value toJSON(const CodeAction &CA)
> return std::move(CodeAction);
> }
>
> +llvm::raw_ostream &operator<<(llvm::raw_ostream &O, const DocumentSymbol &S)
> {
> + return O << S.name << " - " << toJSON(S);
> +}
> +
> +llvm::json::Value toJSON(const DocumentSymbol &S) {
> + json::Object Result{{"name", S.name},
> + {"kind", static_cast<int>(S.kind)},
> + {"range", S.range},
> + {"selectionRange", S.selectionRange}};
> +
> + if (!S.detail.empty())
> + Result["detail"] = S.detail;
> + if (!S.children.empty())
> + Result["children"] = S.children;
> + if (S.deprecated)
> + Result["deprecated"] = true;
> + return Result;
> +}
> +
> json::Value toJSON(const WorkspaceEdit &WE) {
> if (!WE.changes)
> return json::Object{};
>
> Modified: clang-tools-extra/trunk/clangd/Protocol.h
> URL:
> http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/clangd/Protocol.h?rev=347498&r1=347497&r2=347498&view=diff
> ==============================================================================
> --- clang-tools-extra/trunk/clangd/Protocol.h (original)
> +++ clang-tools-extra/trunk/clangd/Protocol.h Fri Nov 23 07:21:19 2018
> @@ -150,6 +150,9 @@ struct Range {
> }
>
> bool contains(Position Pos) const { return start <= Pos && Pos < end; }
> + bool contains(Range Rng) const {
> + return start <= Rng.start && Rng.end <= end;
> + }
> };
> bool fromJSON(const llvm::json::Value &, Range &);
> llvm::json::Value toJSON(const Range &);
> @@ -331,6 +334,9 @@ struct ClientCapabilities {
> /// textDocument.completion.completionItem.snippetSupport
> bool CompletionSnippets = false;
>
> + /// Client supports hierarchical document symbols.
> + bool HierarchicalDocumentSymbol = false;
> +
> /// The supported set of CompletionItemKinds for textDocument/completion.
> /// textDocument.completion.completionItemKind.valueSet
> llvm::Optional<CompletionItemKindBitset> CompletionItemKinds;
> @@ -655,6 +661,39 @@ struct CodeAction {
> };
> llvm::json::Value toJSON(const CodeAction &);
>
> +/// Represents programming constructs like variables, classes, interfaces
> etc.
> +/// that appear in a document. Document symbols can be hierarchical and they
> +/// have two ranges: one that encloses its definition and one that points to
> its
> +/// most interesting range, e.g. the range of an identifier.
> +struct DocumentSymbol {
> + /// The name of this symbol.
> + std::string name;
> +
> + /// More detail for this symbol, e.g the signature of a function.
> + std::string detail;
> +
> + /// The kind of this symbol.
> + SymbolKind kind;
> +
> + /// Indicates if this symbol is deprecated.
> + bool deprecated;
> +
> + /// The range enclosing this symbol not including leading/trailing
> whitespace
> + /// but everything else like comments. This information is typically used
> to
> + /// determine if the clients cursor is inside the symbol to reveal in the
> + /// symbol in the UI.
> + Range range;
> +
> + /// The range that should be selected and revealed when this symbol is
> being
> + /// picked, e.g the name of a function. Must be contained by the `range`.
> + Range selectionRange;
> +
> + /// Children of this symbol, e.g. properties of a class.
> + std::vector<DocumentSymbol> children;
> +};
> +llvm::raw_ostream &operator<<(llvm::raw_ostream &O, const DocumentSymbol &S);
> +llvm::json::Value toJSON(const DocumentSymbol &S);
> +
> /// Represents information about programming constructs like variables,
> classes,
> /// interfaces etc.
> struct SymbolInformation {
>
> Modified: clang-tools-extra/trunk/clangd/clients/clangd-vscode/package.json
> URL:
> http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/clangd/clients/clangd-vscode/package.json?rev=347498&r1=347497&r2=347498&view=diff
> ==============================================================================
> --- clang-tools-extra/trunk/clangd/clients/clangd-vscode/package.json
> (original)
> +++ clang-tools-extra/trunk/clangd/clients/clangd-vscode/package.json Fri Nov
> 23 07:21:19 2018
> @@ -6,7 +6,7 @@
> "publisher": "llvm-vs-code-extensions",
> "homepage": "https://clang.llvm.org/extra/clangd.html";,
> "engines": {
> - "vscode": "^1.18.0"
> + "vscode": "^1.27.0"
> },
> "categories": [
> "Programming Languages",
> @@ -32,8 +32,8 @@
> "test": "node ./node_modules/vscode/bin/test"
> },
> "dependencies": {
> - "vscode-languageclient": "^4.0.0",
> - "vscode-languageserver": "^4.0.0"
> + "vscode-languageclient": "^5.1.0",
> + "vscode-languageserver": "^5.1.0"
> },
> "devDependencies": {
> "typescript": "^2.0.3",
>
> Modified: clang-tools-extra/trunk/unittests/clangd/FindSymbolsTests.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/unittests/clangd/FindSymbolsTests.cpp?rev=347498&r1=347497&r2=347498&view=diff
> ==============================================================================
> --- clang-tools-extra/trunk/unittests/clangd/FindSymbolsTests.cpp (original)
> +++ clang-tools-extra/trunk/unittests/clangd/FindSymbolsTests.cpp Fri Nov 23
> 07:21:19 2018
> @@ -14,6 +14,8 @@
> #include "gmock/gmock.h"
> #include "gtest/gtest.h"
>
> +using namespace llvm;
> +
> namespace clang {
> namespace clangd {
>
> @@ -23,6 +25,7 @@ using ::testing::AllOf;
> using ::testing::AnyOf;
> using ::testing::ElementsAre;
> using ::testing::ElementsAreArray;
> +using ::testing::Field;
> using ::testing::IsEmpty;
> using ::testing::UnorderedElementsAre;
>
> @@ -37,9 +40,17 @@ MATCHER_P(QName, Name, "") {
> return arg.name == Name;
> return (arg.containerName + "::" + arg.name) == Name;
> }
> +MATCHER_P(WithName, N, "") { return arg.name == N; }
> MATCHER_P(WithKind, Kind, "") { return arg.kind == Kind; }
> MATCHER_P(SymRange, Range, "") { return arg.location.range == Range; }
>
> +// GMock helpers for matching DocumentSymbol.
> +MATCHER_P(SymNameRange, Range, "") { return arg.selectionRange == Range; }
> +template <class... ChildMatchers>
> +testing::Matcher<DocumentSymbol> Children(ChildMatchers... ChildrenM) {
> + return Field(&DocumentSymbol::children, ElementsAre(ChildrenM...));
> +}
> +
> ClangdServer::Options optsForTests() {
> auto ServerOpts = ClangdServer::optsForTest();
> ServerOpts.WorkspaceRoot = testRoot();
> @@ -300,7 +311,7 @@ protected:
> IgnoreDiagnostics DiagConsumer;
> ClangdServer Server;
>
> - std::vector<SymbolInformation> getSymbols(PathRef File) {
> + std::vector<DocumentSymbol> getSymbols(PathRef File) {
> EXPECT_TRUE(Server.blockUntilIdleForTest()) << "Waiting for preamble";
> auto SymbolInfos = runDocumentSymbols(Server, File);
> EXPECT_TRUE(bool(SymbolInfos)) << "documentSymbols returned an error";
> @@ -363,31 +374,46 @@ TEST_F(DocumentSymbolsTest, BasicSymbols
> )");
>
> addFile(FilePath, Main.code());
> - EXPECT_THAT(getSymbols(FilePath),
> - ElementsAreArray(
> - {AllOf(QName("Foo"), WithKind(SymbolKind::Class)),
> - AllOf(QName("Foo"), WithKind(SymbolKind::Class)),
> - AllOf(QName("Foo::Foo"), WithKind(SymbolKind::Method)),
> - AllOf(QName("Foo::Foo"), WithKind(SymbolKind::Method)),
> - AllOf(QName("Foo::f"), WithKind(SymbolKind::Method)),
> - AllOf(QName("f1"), WithKind(SymbolKind::Function)),
> - AllOf(QName("Foo::operator="),
> WithKind(SymbolKind::Method)),
> - AllOf(QName("Foo::~Foo"), WithKind(SymbolKind::Method)),
> - AllOf(QName("Foo::Nested"), WithKind(SymbolKind::Class)),
> - AllOf(QName("Foo::Nested::f"),
> WithKind(SymbolKind::Method)),
> - AllOf(QName("Friend"), WithKind(SymbolKind::Class)),
> - AllOf(QName("f1"), WithKind(SymbolKind::Function)),
> - AllOf(QName("f2"), WithKind(SymbolKind::Function)),
> - AllOf(QName("KInt"), WithKind(SymbolKind::Variable)),
> - AllOf(QName("kStr"), WithKind(SymbolKind::Variable)),
> - AllOf(QName("f1"), WithKind(SymbolKind::Function)),
> - AllOf(QName("foo"), WithKind(SymbolKind::Namespace)),
> - AllOf(QName("foo::int32"), WithKind(SymbolKind::Class)),
> - AllOf(QName("foo::int32_t"), WithKind(SymbolKind::Class)),
> - AllOf(QName("foo::v1"), WithKind(SymbolKind::Variable)),
> - AllOf(QName("foo::bar"), WithKind(SymbolKind::Namespace)),
> - AllOf(QName("foo::bar::v2"),
> WithKind(SymbolKind::Variable)),
> - AllOf(QName("foo::baz"),
> WithKind(SymbolKind::Namespace))}));
> + EXPECT_THAT(
> + getSymbols(FilePath),
> + ElementsAreArray(
> + {AllOf(WithName("Foo"), WithKind(SymbolKind::Class), Children()),
> + AllOf(WithName("Foo"), WithKind(SymbolKind::Class),
> + Children(AllOf(WithName("Foo"),
> WithKind(SymbolKind::Method),
> + Children()),
> + AllOf(WithName("Foo"),
> WithKind(SymbolKind::Method),
> + Children()),
> + AllOf(WithName("f"), WithKind(SymbolKind::Method),
> + Children()),
> + AllOf(WithName("operator="),
> + WithKind(SymbolKind::Method), Children()),
> + AllOf(WithName("~Foo"),
> WithKind(SymbolKind::Method),
> + Children()),
> + AllOf(WithName("Nested"),
> WithKind(SymbolKind::Class),
> + Children(AllOf(WithName("f"),
> + WithKind(SymbolKind::Method),
> + Children()))))),
> + AllOf(WithName("Friend"), WithKind(SymbolKind::Class),
> Children()),
> + AllOf(WithName("f1"), WithKind(SymbolKind::Function), Children()),
> + AllOf(WithName("f2"), WithKind(SymbolKind::Function), Children()),
> + AllOf(WithName("KInt"), WithKind(SymbolKind::Variable),
> Children()),
> + AllOf(WithName("kStr"), WithKind(SymbolKind::Variable),
> Children()),
> + AllOf(WithName("f1"), WithKind(SymbolKind::Function), Children()),
> + AllOf(WithName("foo"), WithKind(SymbolKind::Namespace),
> + Children(
> + AllOf(WithName("int32"), WithKind(SymbolKind::Class),
> + Children()),
> + AllOf(WithName("int32_t"), WithKind(SymbolKind::Class),
> + Children()),
> + AllOf(WithName("v1"), WithKind(SymbolKind::Variable),
> + Children()),
> + AllOf(WithName("bar"), WithKind(SymbolKind::Namespace),
> + Children(AllOf(WithName("v2"),
> + WithKind(SymbolKind::Variable),
> + Children()))),
> + AllOf(WithName("baz"), WithKind(SymbolKind::Namespace),
> + Children()),
> + AllOf(WithName("v2"),
> WithKind(SymbolKind::Variable))))}));
> }
>
> TEST_F(DocumentSymbolsTest, DeclarationDefinition) {
> @@ -402,11 +428,12 @@ TEST_F(DocumentSymbolsTest, DeclarationD
>
> addFile(FilePath, Main.code());
> EXPECT_THAT(getSymbols(FilePath),
> - ElementsAre(AllOf(QName("Foo"), WithKind(SymbolKind::Class)),
> - AllOf(QName("Foo::f"),
> WithKind(SymbolKind::Method),
> - SymRange(Main.range("decl"))),
> - AllOf(QName("Foo::f"),
> WithKind(SymbolKind::Method),
> - SymRange(Main.range("def")))));
> + ElementsAre(AllOf(WithName("Foo"), WithKind(SymbolKind::Class),
> + Children(AllOf(
> + WithName("f"),
> WithKind(SymbolKind::Method),
> + SymNameRange(Main.range("decl"))))),
> + AllOf(WithName("f"), WithKind(SymbolKind::Method),
> + SymNameRange(Main.range("def")))));
> }
>
> TEST_F(DocumentSymbolsTest, ExternSymbol) {
> @@ -429,7 +456,7 @@ TEST_F(DocumentSymbolsTest, NoLocals) {
> struct LocalClass {};
> int local_var;
> })cpp");
> - EXPECT_THAT(getSymbols(FilePath), ElementsAre(QName("test")));
> + EXPECT_THAT(getSymbols(FilePath), ElementsAre(WithName("test")));
> }
>
> TEST_F(DocumentSymbolsTest, Unnamed) {
> @@ -442,9 +469,12 @@ TEST_F(DocumentSymbolsTest, Unnamed) {
> )cpp");
> EXPECT_THAT(
> getSymbols(FilePath),
> - ElementsAre(AllOf(QName("UnnamedStruct"),
> WithKind(SymbolKind::Variable)),
> - AllOf(QName("(anonymous struct)::InUnnamed"),
> - WithKind(SymbolKind::Field))));
> + ElementsAre(
> + AllOf(WithName("(anonymous struct)"), WithKind(SymbolKind::Struct),
> + Children(AllOf(WithName("InUnnamed"),
> + WithKind(SymbolKind::Field), Children()))),
> + AllOf(WithName("UnnamedStruct"), WithKind(SymbolKind::Variable),
> + Children())));
> }
>
> TEST_F(DocumentSymbolsTest, InHeaderFile) {
> @@ -461,23 +491,46 @@ TEST_F(DocumentSymbolsTest, InHeaderFile
> addFile("foo.cpp", R"cpp(
> #include "foo.h"
> )cpp");
> - EXPECT_THAT(getSymbols(FilePath), ElementsAre(QName("test")));
> + EXPECT_THAT(getSymbols(FilePath), ElementsAre(WithName("test")));
> }
>
> TEST_F(DocumentSymbolsTest, Template) {
> std::string FilePath = testPath("foo.cpp");
> addFile(FilePath, R"(
> - // Primary templates and specializations are included but instantiations
> - // are not.
> template <class T> struct Tmpl {T x = 0;};
> - template <> struct Tmpl<int> {};
> + template <> struct Tmpl<int> {
> + int y = 0;
> + };
> extern template struct Tmpl<float>;
> template struct Tmpl<double>;
> +
> + template <class T, class U, class Z = float>
> + int funcTmpl(U a);
> + template <>
> + int funcTmpl<int>(double a);
> +
> + template <class T, class U = double>
> + int varTmpl = T();
> + template <>
> + double varTmpl<int> = 10.0;
> )");
> - EXPECT_THAT(getSymbols(FilePath),
> - ElementsAre(AllOf(QName("Tmpl"), WithKind(SymbolKind::Struct)),
> - AllOf(QName("Tmpl::x"),
> WithKind(SymbolKind::Field)),
> - AllOf(QName("Tmpl"),
> WithKind(SymbolKind::Struct))));
> + EXPECT_THAT(
> + getSymbols(FilePath),
> + ElementsAre(
> + AllOf(WithName("Tmpl"), WithKind(SymbolKind::Struct),
> + Children(AllOf(WithName("x"), WithKind(SymbolKind::Field)))),
> + AllOf(WithName("Tmpl<int>"), WithKind(SymbolKind::Struct),
> + Children(WithName("y"))),
> + AllOf(WithName("Tmpl<float>"), WithKind(SymbolKind::Struct),
> + Children()),
> + AllOf(WithName("Tmpl<double>"), WithKind(SymbolKind::Struct),
> + Children()),
> + AllOf(WithName("funcTmpl"), Children()),
> + // FIXME(ibiryukov): template args should be <int> to match the
> code.
> + AllOf(WithName("funcTmpl<int, double, float>"), Children()),
> + AllOf(WithName("varTmpl"), Children()),
> + // FIXME(ibiryukov): template args should be <int> to match the
> code.
> + AllOf(WithName("varTmpl<int, double>"), Children())));
> }
>
> TEST_F(DocumentSymbolsTest, Namespaces) {
> @@ -507,10 +560,15 @@ TEST_F(DocumentSymbolsTest, Namespaces)
> )cpp");
> EXPECT_THAT(
> getSymbols(FilePath),
> - ElementsAreArray({QName("ans1"), QName("ans1::ai1"),
> QName("ans1::ans2"),
> - QName("ans1::ans2::ai2"), QName("test"), QName("na"),
> - QName("na::nb"), QName("na::Foo"), QName("na"),
> - QName("na::nb"), QName("na::Bar")}));
> + ElementsAreArray<testing::Matcher<DocumentSymbol>>(
> + {AllOf(WithName("ans1"),
> + Children(AllOf(WithName("ai1"), Children()),
> + AllOf(WithName("ans2"),
> Children(WithName("ai2"))))),
> + AllOf(WithName("(anonymous namespace)"),
> Children(WithName("test"))),
> + AllOf(WithName("na"),
> + Children(AllOf(WithName("nb"), Children(WithName("Foo"))))),
> + AllOf(WithName("na"),
> + Children(AllOf(WithName("nb"),
> Children(WithName("Bar")))))}));
> }
>
> TEST_F(DocumentSymbolsTest, Enums) {
> @@ -531,10 +589,14 @@ TEST_F(DocumentSymbolsTest, Enums) {
> };
> }
> )");
> - EXPECT_THAT(getSymbols(FilePath),
> - ElementsAre(QName("Red"), QName("Color"), QName("Green"),
> - QName("Color2"), QName("Color2::Yellow"),
> QName("ns"),
> - QName("ns::Black")));
> + EXPECT_THAT(
> + getSymbols(FilePath),
> + ElementsAre(
> + AllOf(WithName("(anonymous enum)"), Children(WithName("Red"))),
> + AllOf(WithName("Color"), Children(WithName("Green"))),
> + AllOf(WithName("Color2"), Children(WithName("Yellow"))),
> + AllOf(WithName("ns"), Children(AllOf(WithName("(anonymous enum)"),
> +
> Children(WithName("Black")))))));
> }
>
> TEST_F(DocumentSymbolsTest, FromMacro) {
> @@ -553,8 +615,43 @@ TEST_F(DocumentSymbolsTest, FromMacro) {
> addFile(FilePath, Main.code());
> EXPECT_THAT(
> getSymbols(FilePath),
> - ElementsAre(AllOf(QName("abc_Test"),
> SymRange(Main.range("expansion"))),
> - AllOf(QName("Test"), SymRange(Main.range("spelling")))));
> + ElementsAre(
> + AllOf(WithName("abc_Test"), SymNameRange(Main.range("expansion"))),
> + AllOf(WithName("Test"), SymNameRange(Main.range("spelling")))));
> +}
> +
> +TEST_F(DocumentSymbolsTest, FuncTemplates) {
> + std::string FilePath = testPath("foo.cpp");
> + Annotations Source(R"cpp(
> + template <class T>
> + T foo() {}
> +
> + auto x = foo<int>();
> + auto y = foo<double>()
> + )cpp");
> + addFile(FilePath, Source.code());
> + // Make sure we only see the template declaration, not instantiations.
> + EXPECT_THAT(getSymbols(FilePath),
> + ElementsAre(WithName("foo"), WithName("x"), WithName("y")));
> +}
> +
> +TEST_F(DocumentSymbolsTest, UsingDirectives) {
> + std::string FilePath = testPath("foo.cpp");
> + Annotations Source(R"cpp(
> + namespace ns {
> + int foo;
> + }
> +
> + namespace ns_alias = ns;
> +
> + using namespace ::ns; // check we don't loose qualifiers.
> + using namespace ns_alias; // and namespace aliases.
> + )cpp");
> + addFile(FilePath, Source.code());
> + EXPECT_THAT(getSymbols(FilePath),
> + ElementsAre(WithName("ns"), WithName("ns_alias"),
> + WithName("using namespace ::ns"),
> + WithName("using namespace ns_alias")));
> }
>
> } // namespace clangd
>
> Modified: clang-tools-extra/trunk/unittests/clangd/SyncAPI.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/unittests/clangd/SyncAPI.cpp?rev=347498&r1=347497&r2=347498&view=diff
> ==============================================================================
> --- clang-tools-extra/trunk/unittests/clangd/SyncAPI.cpp (original)
> +++ clang-tools-extra/trunk/unittests/clangd/SyncAPI.cpp Fri Nov 23 07:21:19
> 2018
> @@ -120,9 +120,9 @@ runWorkspaceSymbols(ClangdServer &Server
> return std::move(*Result);
> }
>
> -Expected<std::vector<SymbolInformation>>
> -runDocumentSymbols(ClangdServer &Server, PathRef File) {
> - Optional<Expected<std::vector<SymbolInformation>>> Result;
> +Expected<std::vector<DocumentSymbol>> runDocumentSymbols(ClangdServer
> &Server,
> + PathRef File) {
> + Optional<Expected<std::vector<DocumentSymbol>>> Result;
> Server.documentSymbols(File, capture(Result));
> return std::move(*Result);
> }
>
> Modified: clang-tools-extra/trunk/unittests/clangd/SyncAPI.h
> URL:
> http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/unittests/clangd/SyncAPI.h?rev=347498&r1=347497&r2=347498&view=diff
> ==============================================================================
> --- clang-tools-extra/trunk/unittests/clangd/SyncAPI.h (original)
> +++ clang-tools-extra/trunk/unittests/clangd/SyncAPI.h Fri Nov 23 07:21:19
> 2018
> @@ -47,8 +47,8 @@ std::string runDumpAST(ClangdServer &Ser
> llvm::Expected<std::vector<SymbolInformation>>
> runWorkspaceSymbols(ClangdServer &Server, StringRef Query, int Limit);
>
> -llvm::Expected<std::vector<SymbolInformation>>
> -runDocumentSymbols(ClangdServer &Server, PathRef File);
> +Expected<std::vector<DocumentSymbol>> runDocumentSymbols(ClangdServer
> &Server,
> + PathRef File);
>
> SymbolSlab runFuzzyFind(const SymbolIndex &Index, StringRef Query);
> SymbolSlab runFuzzyFind(const SymbolIndex &Index, const FuzzyFindRequest
> &Req);
>
>
> _______________________________________________
> cfe-commits mailing list
> cfe-commits@lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
>
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
