[clang-tools-extra] r347498 - [clangd] Add support for hierarchical documentSymbol
Mikael Holmén via cfe-commits
cfe-commits at lists.llvm.org
Mon Nov 26 04:22:43 PST 2018
On 11/26/18 12:41 PM, Ilya Biryukov wrote:
> Sorry about that, should be fixed in r347539.
>
Yep, thanks!
/Mikael
> On Mon, Nov 26, 2018 at 8:10 AM Mikael Holmén
> <mikael.holmen at ericsson.com <mailto:mikael.holmen at ericsson.com>> wrote:
>
> 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 <http://arg.name> == Name;
> > return (arg.containerName + "::" + arg.name
> <http://arg.name>) == Name;
> > }
> > +MATCHER_P(WithName, N, "") { return arg.name <http://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 at lists.llvm.org <mailto:cfe-commits at lists.llvm.org>
> > http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
> >
>
>
>
> --
> Regards,
> Ilya Biryukov
More information about the cfe-commits
mailing list