malaperle updated this revision to Diff 141028.
malaperle marked 27 inline comments as done.
malaperle added a comment.
Address comments.
Repository:
rCTE Clang Tools Extra
https://reviews.llvm.org/D44882
Files:
clangd/CMakeLists.txt
clangd/ClangdLSPServer.cpp
clangd/ClangdLSPServer.h
clangd/ClangdServer.cpp
clangd/ClangdServer.h
clangd/FindSymbols.cpp
clangd/FindSymbols.h
clangd/Protocol.cpp
clangd/Protocol.h
clangd/ProtocolHandlers.cpp
clangd/ProtocolHandlers.h
clangd/SourceCode.cpp
clangd/SourceCode.h
clangd/XRefs.cpp
clangd/index/SymbolCollector.cpp
clangd/tool/ClangdMain.cpp
test/clangd/initialize-params-invalid.test
test/clangd/initialize-params.test
unittests/clangd/CMakeLists.txt
unittests/clangd/FindSymbolsTests.cpp
unittests/clangd/SyncAPI.cpp
unittests/clangd/SyncAPI.h
Index: unittests/clangd/SyncAPI.h
===================================================================
--- unittests/clangd/SyncAPI.h
+++ unittests/clangd/SyncAPI.h
@@ -41,6 +41,10 @@
std::string runDumpAST(ClangdServer &Server, PathRef File);
+llvm::Expected<std::vector<SymbolInformation>>
+runWorkspaceSymbols(ClangdServer &Server, StringRef Query,
+ const WorkspaceSymbolOptions &Opts, const DraftStore &DS);
+
} // namespace clangd
} // namespace clang
Index: unittests/clangd/SyncAPI.cpp
===================================================================
--- unittests/clangd/SyncAPI.cpp
+++ unittests/clangd/SyncAPI.cpp
@@ -110,5 +110,13 @@
return std::move(*Result);
}
+llvm::Expected<std::vector<SymbolInformation>>
+runWorkspaceSymbols(ClangdServer &Server, StringRef Query,
+ const WorkspaceSymbolOptions &Opts, const DraftStore &DS) {
+ llvm::Optional<llvm::Expected<std::vector<SymbolInformation>>> Result;
+ Server.workspaceSymbols(Query, Opts, DS, capture(Result));
+ return std::move(*Result);
+}
+
} // namespace clangd
} // namespace clang
Index: unittests/clangd/FindSymbolsTests.cpp
===================================================================
--- /dev/null
+++ unittests/clangd/FindSymbolsTests.cpp
@@ -0,0 +1,249 @@
+//===-- FindSymbolsTests.cpp -------------------------*- C++ -*------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include "Annotations.h"
+#include "ClangdServer.h"
+#include "DraftStore.h"
+#include "FindSymbols.h"
+#include "SyncAPI.h"
+#include "TestFS.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+namespace clang {
+namespace clangd {
+
+namespace {
+
+using ::testing::AllOf;
+using ::testing::AnyOf;
+using ::testing::ElementsAre;
+using ::testing::IsEmpty;
+using ::testing::UnorderedElementsAre;
+
+class IgnoreDiagnostics : public DiagnosticsConsumer {
+ void onDiagnosticsReady(PathRef File,
+ std::vector<Diag> Diagnostics) override {}
+};
+
+// GMock helpers for matching SymbolInfos items.
+MATCHER_P(Named, Name, "") { return arg.name == Name; }
+MATCHER_P(InContainer, ContainerName, "") {
+ return arg.containerName == ContainerName;
+}
+MATCHER_P(WithKind, Kind, "") { return arg.kind == Kind; }
+
+ClangdServer::Options optsForTests() {
+ auto ServerOpts = ClangdServer::optsForTest();
+ ServerOpts.BuildDynamicSymbolIndex = true;
+ return ServerOpts;
+}
+
+class WorkspaceSymbolsTest : public ::testing::Test {
+public:
+ WorkspaceSymbolsTest()
+ : Server(CDB, FSProvider, DiagConsumer, optsForTests()) {}
+
+protected:
+ MockFSProvider FSProvider;
+ MockCompilationDatabase CDB;
+ IgnoreDiagnostics DiagConsumer;
+ ClangdServer Server;
+ WorkspaceSymbolOptions Opts;
+ DraftStore DS;
+
+ std::vector<SymbolInformation> getSymbols(StringRef Query) {
+ EXPECT_TRUE(Server.blockUntilIdleForTest()) << "Waiting for preamble";
+ auto SymbolInfos = runWorkspaceSymbols(Server, Query, Opts, DS);
+ EXPECT_TRUE(bool(SymbolInfos)) << "workspaceSymbols returned an error";
+ return *SymbolInfos;
+ }
+
+ void addFile(StringRef FileName, StringRef Contents) {
+ auto Path = testPath(FileName);
+ FSProvider.Files[Path] = Contents;
+ Server.addDocument(Path, Contents);
+ }
+};
+
+} // namespace
+
+TEST_F(WorkspaceSymbolsTest, NoMacro) {
+ addFile("foo.cpp", R"cpp(
+ #define MACRO X
+ )cpp");
+
+ // Macros are not in the index.
+ EXPECT_THAT(getSymbols("macro"), IsEmpty());
+}
+
+TEST_F(WorkspaceSymbolsTest, NoLocals) {
+ addFile("foo.cpp", R"cpp(
+ void test(int FirstParam, int SecondParam) {
+ struct LocalClass {};
+ int local_var;
+ })cpp");
+ EXPECT_THAT(getSymbols("l"), IsEmpty());
+ EXPECT_THAT(getSymbols("p"), IsEmpty());
+}
+
+TEST_F(WorkspaceSymbolsTest, Globals) {
+ addFile("foo.h", R"cpp(
+ int global_var;
+
+ int global_func();
+
+ struct GlobalStruct {};)cpp");
+ addFile("foo.cpp", R"cpp(
+ #include "foo.h"
+ )cpp");
+ EXPECT_THAT(getSymbols("global"),
+ UnorderedElementsAre(AllOf(Named("GlobalStruct"), InContainer(""),
+ WithKind(SymbolKind::Struct)),
+ AllOf(Named("global_func"), InContainer(""),
+ WithKind(SymbolKind::Function)),
+ AllOf(Named("global_var"), InContainer(""),
+ WithKind(SymbolKind::Variable))));
+}
+
+TEST_F(WorkspaceSymbolsTest, Unnamed) {
+ addFile("foo.h", R"cpp(
+ struct {
+ int InUnnamed;
+ } UnnamedStruct;)cpp");
+ addFile("foo.cpp", R"cpp(
+ #include "foo.h"
+ )cpp");
+ EXPECT_THAT(getSymbols("UnnamedStruct"),
+ ElementsAre(AllOf(Named("UnnamedStruct"),
+ WithKind(SymbolKind::Variable))));
+ EXPECT_THAT(getSymbols("InUnnamed"), IsEmpty());
+}
+
+TEST_F(WorkspaceSymbolsTest, InMainFile) {
+ addFile("foo.cpp", R"cpp(
+ int test() {
+ }
+ )cpp");
+ EXPECT_THAT(getSymbols("test"), IsEmpty());
+}
+
+TEST_F(WorkspaceSymbolsTest, Namespaces) {
+ addFile("foo.h", R"cpp(
+ namespace ans1 {
+ int ai1;
+ namespace ans2 {
+ int ai2;
+ }
+ }
+ )cpp");
+ addFile("foo.cpp", R"cpp(
+ #include "foo.h"
+ )cpp");
+ EXPECT_THAT(
+ getSymbols("a"),
+ UnorderedElementsAre(AllOf(Named("ans1"), InContainer("")),
+ AllOf(Named("ai1"), InContainer("ans1")),
+ AllOf(Named("ans2"), InContainer("ans1")),
+ AllOf(Named("ai2"), InContainer("ans1::ans2"))));
+ EXPECT_THAT(getSymbols("::"),
+ ElementsAre(AllOf(Named("ans1"), InContainer(""))));
+ EXPECT_THAT(getSymbols("::a"),
+ ElementsAre(AllOf(Named("ans1"), InContainer(""))));
+ EXPECT_THAT(getSymbols("ans1::"),
+ UnorderedElementsAre(AllOf(Named("ai1"), InContainer("ans1")),
+ AllOf(Named("ans2"), InContainer("ans1"))));
+ EXPECT_THAT(getSymbols("::ans1"),
+ ElementsAre(AllOf(Named("ans1"), InContainer(""))));
+ EXPECT_THAT(getSymbols("::ans1::"),
+ UnorderedElementsAre(AllOf(Named("ai1"), InContainer("ans1")),
+ AllOf(Named("ans2"), InContainer("ans1"))));
+ EXPECT_THAT(getSymbols("::ans1::ans2"),
+ ElementsAre(AllOf(Named("ans2"), InContainer("ans1"))));
+ EXPECT_THAT(getSymbols("::ans1::ans2::"),
+ ElementsAre(AllOf(Named("ai2"), InContainer("ans1::ans2"))));
+}
+
+TEST_F(WorkspaceSymbolsTest, AnonymousNamespace) {
+ addFile("foo.h", R"cpp(
+ namespace {
+ void test() {}
+ }
+ )cpp");
+ addFile("foo.cpp", R"cpp(
+ #include "foo.h"
+ )cpp");
+ EXPECT_THAT(getSymbols("test"), IsEmpty());
+}
+
+TEST_F(WorkspaceSymbolsTest, MultiFile) {
+ addFile("foo.h", R"cpp(
+ int foo() {
+ }
+ )cpp");
+ addFile("foo2.h", R"cpp(
+ int foo2() {
+ }
+ )cpp");
+ addFile("foo.cpp", R"cpp(
+ #include "foo.h"
+ #include "foo2.h"
+ )cpp");
+ EXPECT_THAT(getSymbols("foo"),
+ UnorderedElementsAre(AllOf(Named("foo"), InContainer("")),
+ AllOf(Named("foo2"), InContainer(""))));
+}
+
+TEST_F(WorkspaceSymbolsTest, GlobalNamespaceQueries) {
+ addFile("foo.h", R"cpp(
+ int foo() {
+ }
+ class Foo {
+ int a;
+ };
+ namespace ns {
+ int foo2() {
+ }
+ }
+ )cpp");
+ addFile("foo.cpp", R"cpp(
+ #include "foo.h"
+ )cpp");
+ EXPECT_THAT(
+ getSymbols("::"),
+ UnorderedElementsAre(
+ AllOf(Named("Foo"), InContainer(""), WithKind(SymbolKind::Class)),
+ AllOf(Named("foo"), InContainer(""), WithKind(SymbolKind::Function)),
+ AllOf(Named("ns"), InContainer(""),
+ WithKind(SymbolKind::Namespace))));
+ EXPECT_THAT(getSymbols(":"), IsEmpty());
+ EXPECT_THAT(getSymbols(""), IsEmpty());
+}
+
+TEST_F(WorkspaceSymbolsTest, WithLimit) {
+ addFile("foo.h", R"cpp(
+ int foo;
+ int foo2;
+ )cpp");
+ addFile("foo.cpp", R"cpp(
+ #include "foo.h"
+ )cpp");
+ EXPECT_THAT(getSymbols("foo"),
+ ElementsAre(AllOf(Named("foo"), InContainer(""),
+ WithKind(SymbolKind::Variable)),
+ AllOf(Named("foo2"), InContainer(""),
+ WithKind(SymbolKind::Variable))));
+
+ Opts.Limit = 1;
+ EXPECT_THAT(getSymbols("foo"),
+ ElementsAre(AnyOf((Named("foo"), InContainer("")),
+ AllOf(Named("foo2"), InContainer("")))));
+}
+
+} // namespace clangd
+} // namespace clang
Index: unittests/clangd/CMakeLists.txt
===================================================================
--- unittests/clangd/CMakeLists.txt
+++ unittests/clangd/CMakeLists.txt
@@ -17,6 +17,7 @@
ContextTests.cpp
DraftStoreTests.cpp
FileIndexTests.cpp
+ FindSymbolsTests.cpp
FuzzyMatchTests.cpp
HeadersTests.cpp
IndexTests.cpp
Index: test/clangd/initialize-params.test
===================================================================
--- test/clangd/initialize-params.test
+++ test/clangd/initialize-params.test
@@ -36,7 +36,8 @@
# CHECK-NEXT: ","
# CHECK-NEXT: ]
# CHECK-NEXT: },
-# CHECK-NEXT: "textDocumentSync": 2
+# CHECK-NEXT: "textDocumentSync": 2,
+# CHECK-NEXT: "workspaceSymbolProvider": true
# CHECK-NEXT: }
# CHECK-NEXT: }
---
Index: test/clangd/initialize-params-invalid.test
===================================================================
--- test/clangd/initialize-params-invalid.test
+++ test/clangd/initialize-params-invalid.test
@@ -36,7 +36,8 @@
# CHECK-NEXT: ","
# CHECK-NEXT: ]
# CHECK-NEXT: },
-# CHECK-NEXT: "textDocumentSync": 2
+# CHECK-NEXT: "textDocumentSync": 2,
+# CHECK-NEXT: "workspaceSymbolProvider": true
# CHECK-NEXT: }
# CHECK-NEXT: }
---
Index: clangd/tool/ClangdMain.cpp
===================================================================
--- clangd/tool/ClangdMain.cpp
+++ clangd/tool/ClangdMain.cpp
@@ -96,9 +96,9 @@
clEnumValN(PCHStorageFlag::Memory, "memory", "store PCHs in memory")),
llvm::cl::init(PCHStorageFlag::Disk));
-static llvm::cl::opt<int> LimitCompletionResult(
- "completion-limit",
- llvm::cl::desc("Limit the number of completion results returned by clangd. "
+static llvm::cl::opt<int> LimitResults(
+ "limit-results",
+ llvm::cl::desc("Limit the number of results returned by clangd. "
"0 means no limit."),
llvm::cl::init(100));
@@ -118,11 +118,11 @@
"Mirror all LSP input to the specified file. Useful for debugging."),
llvm::cl::init(""), llvm::cl::Hidden);
-static llvm::cl::opt<bool> EnableIndexBasedCompletion(
- "enable-index-based-completion",
- llvm::cl::desc(
- "Enable index-based global code completion. "
- "Clang uses an index built from symbols in opened files"),
+static llvm::cl::opt<bool> EnableIndex(
+ "index",
+ llvm::cl::desc("Enable index-based features such as global code completion "
+ "and searching for symbols."
+ "Clang uses an index built from symbols in opened files"),
llvm::cl::init(true));
static llvm::cl::opt<Path> YamlSymbolFile(
@@ -220,20 +220,23 @@
}
if (!ResourceDir.empty())
Opts.ResourceDir = ResourceDir;
- Opts.BuildDynamicSymbolIndex = EnableIndexBasedCompletion;
+ Opts.BuildDynamicSymbolIndex = EnableIndex;
std::unique_ptr<SymbolIndex> StaticIdx;
- if (EnableIndexBasedCompletion && !YamlSymbolFile.empty()) {
+ if (EnableIndex && !YamlSymbolFile.empty()) {
StaticIdx = BuildStaticIndex(YamlSymbolFile);
Opts.StaticIndex = StaticIdx.get();
}
Opts.AsyncThreadsCount = WorkerThreadsCount;
clangd::CodeCompleteOptions CCOpts;
CCOpts.IncludeIneligibleResults = IncludeIneligibleResults;
- CCOpts.Limit = LimitCompletionResult;
+ CCOpts.Limit = LimitResults;
+ clangd::WorkspaceSymbolOptions WorkspaceSymOpts;
+ WorkspaceSymOpts.Limit = LimitResults;
// Initialize and run ClangdLSPServer.
- ClangdLSPServer LSPServer(Out, CCOpts, CompileCommandsDirPath, Opts);
+ ClangdLSPServer LSPServer(Out, CCOpts, WorkspaceSymOpts,
+ CompileCommandsDirPath, Opts);
constexpr int NoShutdownRequestErrorCode = 1;
llvm::set_thread_name("clangd.main");
// Change stdin to binary to not lose \r\n on windows.
Index: clangd/index/SymbolCollector.cpp
===================================================================
--- clangd/index/SymbolCollector.cpp
+++ clangd/index/SymbolCollector.cpp
@@ -11,6 +11,7 @@
#include "../AST.h"
#include "../CodeCompletionStrings.h"
#include "../Logger.h"
+#include "../SourceCode.h"
#include "../URI.h"
#include "CanonicalIncludes.h"
#include "clang/AST/DeclCXX.h"
@@ -80,16 +81,6 @@
return llvm::None;
}
-// "a::b::c", return {"a::b::", "c"}. Scope is empty if there's no qualifier.
-std::pair<llvm::StringRef, llvm::StringRef>
-splitQualifiedName(llvm::StringRef QName) {
- assert(!QName.startswith("::") && "Qualified names should not start with ::");
- size_t Pos = QName.rfind("::");
- if (Pos == llvm::StringRef::npos)
- return {StringRef(), QName};
- return {QName.substr(0, Pos + 2), QName.substr(Pos + 2)};
-}
-
bool shouldFilterDecl(const NamedDecl *ND, ASTContext *ASTCtx,
const SymbolCollector::Options &Opts) {
using namespace clang::ast_matchers;
@@ -296,6 +287,7 @@
Policy.SuppressUnwrittenScope = true;
ND.printQualifiedName(OS, Policy);
OS.flush();
+ assert(!StringRef(QName).startswith("::"));
Symbol S;
S.ID = std::move(ID);
Index: clangd/XRefs.cpp
===================================================================
--- clangd/XRefs.cpp
+++ clangd/XRefs.cpp
@@ -143,8 +143,8 @@
}
};
-llvm::Optional<Location>
-makeLocation(ParsedAST &AST, const SourceRange &ValSourceRange) {
+llvm::Optional<Location> makeLocation(ParsedAST &AST,
+ const SourceRange &ValSourceRange) {
const SourceManager &SourceMgr = AST.getASTContext().getSourceManager();
const LangOptions &LangOpts = AST.getASTContext().getLangOpts();
SourceLocation LocStart = ValSourceRange.getBegin();
Index: clangd/SourceCode.h
===================================================================
--- clangd/SourceCode.h
+++ clangd/SourceCode.h
@@ -49,6 +49,11 @@
// Note that clang also uses closed source ranges, which this can't handle!
Range halfOpenToRange(const SourceManager &SM, CharSourceRange R);
+/// From "a::b::c", return {"a::b::", "c"}. Scope is empty if there's no
+/// qualifier.
+std::pair<llvm::StringRef, llvm::StringRef>
+splitQualifiedName(llvm::StringRef QName);
+
} // namespace clangd
} // namespace clang
#endif
Index: clangd/SourceCode.cpp
===================================================================
--- clangd/SourceCode.cpp
+++ clangd/SourceCode.cpp
@@ -76,5 +76,13 @@
return {Begin, End};
}
+std::pair<llvm::StringRef, llvm::StringRef>
+splitQualifiedName(llvm::StringRef QName) {
+ size_t Pos = QName.rfind("::");
+ if (Pos == llvm::StringRef::npos)
+ return {StringRef(), QName};
+ return {QName.substr(0, Pos + 2), QName.substr(Pos + 2)};
+}
+
} // namespace clangd
} // namespace clang
Index: clangd/ProtocolHandlers.h
===================================================================
--- clangd/ProtocolHandlers.h
+++ clangd/ProtocolHandlers.h
@@ -49,6 +49,7 @@
virtual void onSwitchSourceHeader(TextDocumentIdentifier &Params) = 0;
virtual void onFileEvent(DidChangeWatchedFilesParams &Params) = 0;
virtual void onCommand(ExecuteCommandParams &Params) = 0;
+ virtual void onWorkspaceSymbol(WorkspaceSymbolParams &Params) = 0;
virtual void onRename(RenameParams &Parames) = 0;
virtual void onDocumentHighlight(TextDocumentPositionParams &Params) = 0;
virtual void onHover(TextDocumentPositionParams &Params) = 0;
Index: clangd/ProtocolHandlers.cpp
===================================================================
--- clangd/ProtocolHandlers.cpp
+++ clangd/ProtocolHandlers.cpp
@@ -72,4 +72,5 @@
&ProtocolCallbacks::onDocumentHighlight);
Register("workspace/didChangeConfiguration",
&ProtocolCallbacks::onChangeConfiguration);
+ Register("workspace/symbol", &ProtocolCallbacks::onWorkspaceSymbol);
}
Index: clangd/Protocol.h
===================================================================
--- clangd/Protocol.h
+++ clangd/Protocol.h
@@ -27,6 +27,7 @@
#include "JSONExpr.h"
#include "URI.h"
#include "llvm/ADT/Optional.h"
+#include <bitset>
#include <string>
#include <vector>
@@ -237,6 +238,69 @@
};
bool fromJSON(const json::Expr &, CompletionClientCapabilities &);
+/// A symbol kind.
+enum class SymbolKind : uint32_t {
+ File = 1,
+ Module = 2,
+ Namespace = 3,
+ Package = 4,
+ Class = 5,
+ Method = 6,
+ Property = 7,
+ Field = 8,
+ Constructor = 9,
+ Enum = 10,
+ Interface = 11,
+ Function = 12,
+ Variable = 13,
+ Constant = 14,
+ String = 15,
+ Number = 16,
+ Boolean = 17,
+ Array = 18,
+ Object = 19,
+ Key = 20,
+ Null = 21,
+ EnumMember = 22,
+ Struct = 23,
+ Event = 24,
+ Operator = 25,
+ TypeParameter = 26
+};
+
+using SymKindUnderlyingType = std::underlying_type<SymbolKind>::type;
+constexpr auto SymbolKindMin =
+ static_cast<SymKindUnderlyingType>(SymbolKind::File);
+constexpr auto SymbolKindMax =
+ static_cast<SymKindUnderlyingType>(SymbolKind::TypeParameter);
+using SymbolKindBitset = std::bitset<SymbolKindMax + 1>;
+
+bool fromJSON(const json::Expr &, SymbolKind &);
+
+struct SymbolKindCapabilities {
+ /// The SymbolKinds that the client supports. If not set, the client only
+ /// supports <= SymbolKind::Array and will not fall back to a valid default
+ /// value.
+ llvm::Optional<std::vector<SymbolKind>> valueSet;
+};
+bool fromJSON(const json::Expr &, SymbolKindCapabilities &);
+SymbolKind adjustKindToCapability(SymbolKind Kind,
+ SymbolKindBitset &supportedSymbolKinds);
+
+struct WorkspaceSymbolCapabilities {
+ /// Capabilities SymbolKind.
+ llvm::Optional<SymbolKindCapabilities> symbolKind;
+};
+bool fromJSON(const json::Expr &, WorkspaceSymbolCapabilities &);
+
+// FIXME: most of the capabilities are missing from this struct. Only the ones
+// used by clangd are currently there.
+struct WorkspaceClientCapabilities {
+ /// Capabilities specific to `workspace/symbol`.
+ llvm::Optional<WorkspaceSymbolCapabilities> symbol;
+};
+bool fromJSON(const json::Expr &, WorkspaceClientCapabilities &);
+
// FIXME: most of the capabilities are missing from this struct. Only the ones
// used by clangd are currently there.
struct TextDocumentClientCapabilities {
@@ -247,8 +311,7 @@
struct ClientCapabilities {
// Workspace specific client capabilities.
- // NOTE: not used by clangd at the moment.
- // WorkspaceClientCapabilities workspace;
+ llvm::Optional<WorkspaceClientCapabilities> workspace;
// Text document specific client capabilities.
TextDocumentClientCapabilities textDocument;
@@ -525,6 +588,31 @@
json::Expr toJSON(const Command &C);
+/// Represents information about programming constructs like variables, classes,
+/// interfaces etc.
+struct SymbolInformation {
+ /// The name of this symbol.
+ std::string name;
+
+ /// The kind of this symbol.
+ SymbolKind kind;
+
+ /// The location of this symbol.
+ Location location;
+
+ /// The name of the symbol containing this symbol.
+ std::string containerName;
+};
+json::Expr toJSON(const SymbolInformation &);
+llvm::raw_ostream &operator<<(llvm::raw_ostream &, const SymbolInformation &);
+
+/// The parameters of a Workspace Symbol Request.
+struct WorkspaceSymbolParams {
+ /// A non-empty query string
+ std::string query;
+};
+bool fromJSON(const json::Expr &, WorkspaceSymbolParams &);
+
struct ApplyWorkspaceEditParams {
WorkspaceEdit edit;
};
Index: clangd/Protocol.cpp
===================================================================
--- clangd/Protocol.cpp
+++ clangd/Protocol.cpp
@@ -176,6 +176,50 @@
return true;
}
+bool fromJSON(const json::Expr &E, SymbolKind &Out) {
+ if (auto T = E.asInteger()) {
+ if (*T < static_cast<int>(SymbolKind::File) ||
+ *T > static_cast<int>(SymbolKind::TypeParameter))
+ return false;
+ Out = static_cast<SymbolKind>(*T);
+ return true;
+ }
+ return false;
+}
+
+bool fromJSON(const json::Expr &Params, SymbolKindCapabilities &R) {
+ json::ObjectMapper O(Params);
+ return O && O.map("valueSet", R.valueSet);
+}
+
+SymbolKind adjustKindToCapability(SymbolKind Kind,
+ SymbolKindBitset &supportedSymbolKinds) {
+ auto KindVal = static_cast<SymKindUnderlyingType>(Kind);
+ if (KindVal >= SymbolKindMin && KindVal <= supportedSymbolKinds.size() &&
+ supportedSymbolKinds[KindVal])
+ return Kind;
+
+ switch (Kind) {
+ // Provide some fall backs for common kinds that are close enough.
+ case SymbolKind::Struct:
+ return SymbolKind::Class;
+ case SymbolKind::EnumMember:
+ return SymbolKind::Enum;
+ default:
+ llvm_unreachable("Unexpected symbol kind");
+ }
+}
+
+bool fromJSON(const json::Expr &Params, WorkspaceSymbolCapabilities &R) {
+ json::ObjectMapper O(Params);
+ return O && O.map("symbolKind", R.symbolKind);
+}
+
+bool fromJSON(const json::Expr &Params, WorkspaceClientCapabilities &R) {
+ json::ObjectMapper O(Params);
+ return O && O.map("symbol", R.symbol);
+}
+
bool fromJSON(const json::Expr &Params, TextDocumentClientCapabilities &R) {
json::ObjectMapper O(Params);
if (!O)
@@ -189,6 +233,7 @@
if (!O)
return false;
O.map("textDocument", R.textDocument);
+ O.map("workspace", R.workspace);
return true;
}
@@ -351,6 +396,26 @@
return false; // Unrecognized command.
}
+json::Expr toJSON(const SymbolInformation &P) {
+ return json::obj{
+ {"name", P.name},
+ {"kind", static_cast<int>(P.kind)},
+ {"location", P.location},
+ {"containerName", P.containerName},
+ };
+}
+
+llvm::raw_ostream &operator<<(llvm::raw_ostream &O,
+ const SymbolInformation &SI) {
+ O << SI.containerName << "::" << SI.name << " - " << toJSON(SI);
+ return O;
+}
+
+bool fromJSON(const json::Expr &Params, WorkspaceSymbolParams &R) {
+ json::ObjectMapper O(Params);
+ return O && O.map("query", R.query);
+}
+
json::Expr toJSON(const Command &C) {
auto Cmd = json::obj{{"title", C.title}, {"command", C.command}};
if (C.workspaceEdit)
Index: clangd/FindSymbols.h
===================================================================
--- /dev/null
+++ clangd/FindSymbols.h
@@ -0,0 +1,40 @@
+//===--- FindSymbols.h --------------------------------------*- C++-*------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Queries that provide a list of symbols matching a string.
+//
+//===----------------------------------------------------------------------===//
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_WORKSPACESYMBOL_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_WORKSPACESYMBOL_H
+
+#include "Protocol.h"
+#include "clang/Basic/VirtualFileSystem.h"
+#include "llvm/ADT/IntrusiveRefCntPtr.h"
+#include "llvm/ADT/StringRef.h"
+
+namespace clang {
+namespace clangd {
+class SymbolIndex;
+class DraftStore;
+
+struct WorkspaceSymbolOptions {
+ /// Limit the number of results returned (0 means no limit).
+ size_t Limit = 0;
+};
+
+llvm::Expected<std::vector<SymbolInformation>>
+getWorkspaceSymbols(llvm::StringRef Query, const WorkspaceSymbolOptions &Opts,
+ const SymbolIndex *const Index,
+ llvm::IntrusiveRefCntPtr<vfs::FileSystem> VFS,
+ const DraftStore &DS);
+
+} // namespace clangd
+} // namespace clang
+
+#endif
Index: clangd/FindSymbols.cpp
===================================================================
--- /dev/null
+++ clangd/FindSymbols.cpp
@@ -0,0 +1,186 @@
+//===--- FindSymbols.cpp ------------------------------------*- C++-*------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include "FindSymbols.h"
+
+#include "DraftStore.h"
+#include "Logger.h"
+#include "SourceCode.h"
+#include "index/Index.h"
+#include "clang/Basic/SourceManager.h"
+#include "clang/Frontend/CompilerInstance.h"
+#include "clang/Index/IndexSymbol.h"
+#include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/Path.h"
+
+namespace clang {
+namespace clangd {
+
+namespace {
+
+// Convert a index::SymbolKind to clangd::SymbolKind (LSP)
+// Note, some are not perfect matches and should be improved when this LSP
+// issue is addressed:
+// https://github.com/Microsoft/language-server-protocol/issues/344
+SymbolKind indexSymbolKindToSymbolKind(index::SymbolKind Kind) {
+ switch (Kind) {
+ case index::SymbolKind::Unknown:
+ return SymbolKind::Variable;
+ case index::SymbolKind::Module:
+ return SymbolKind::Module;
+ case index::SymbolKind::Namespace:
+ return SymbolKind::Namespace;
+ case index::SymbolKind::NamespaceAlias:
+ return SymbolKind::Namespace;
+ case index::SymbolKind::Macro:
+ return SymbolKind::String;
+ case index::SymbolKind::Enum:
+ return SymbolKind::Enum;
+ case index::SymbolKind::Struct:
+ return SymbolKind::Struct;
+ case index::SymbolKind::Class:
+ return SymbolKind::Class;
+ case index::SymbolKind::Protocol:
+ return SymbolKind::Interface;
+ case index::SymbolKind::Extension:
+ return SymbolKind::Interface;
+ case index::SymbolKind::Union:
+ return SymbolKind::Class;
+ case index::SymbolKind::TypeAlias:
+ return SymbolKind::Class;
+ case index::SymbolKind::Function:
+ return SymbolKind::Function;
+ case index::SymbolKind::Variable:
+ return SymbolKind::Variable;
+ case index::SymbolKind::Field:
+ return SymbolKind::Field;
+ case index::SymbolKind::EnumConstant:
+ return SymbolKind::EnumMember;
+ case index::SymbolKind::InstanceMethod:
+ case index::SymbolKind::ClassMethod:
+ case index::SymbolKind::StaticMethod:
+ return SymbolKind::Method;
+ case index::SymbolKind::InstanceProperty:
+ case index::SymbolKind::ClassProperty:
+ case index::SymbolKind::StaticProperty:
+ return SymbolKind::Property;
+ case index::SymbolKind::Constructor:
+ case index::SymbolKind::Destructor:
+ return SymbolKind::Method;
+ case index::SymbolKind::ConversionFunction:
+ return SymbolKind::Function;
+ case index::SymbolKind::Parameter:
+ return SymbolKind::Variable;
+ case index::SymbolKind::Using:
+ return SymbolKind::Namespace;
+ }
+ llvm_unreachable("invalid symbol kind");
+}
+
+llvm::Optional<Location> makeLocation(const DraftStore &DS,
+ SourceManager &SourceMgr,
+ StringRef FilePath, size_t OffsetStart,
+ size_t OffsetEnd) {
+ auto Code = DS.getDraft(FilePath);
+ // If an unsaved file exists, use its buffer to to the offset -> Position
+ // otherwise it might end up being the wrong location. This assumes
+ // OffsetStart/OffsetEnd are the most up to date in regards to unsaved files.
+ if (Code) {
+ Position Begin = offsetToPosition(*Code, OffsetStart);
+ Position End = offsetToPosition(*Code, OffsetEnd);
+ Location L;
+ L.uri = URIForFile(FilePath);
+ L.range = {Begin, End};
+ return L;
+ }
+
+ const FileEntry *FE = SourceMgr.getFileManager().getFile(FilePath);
+ if (!FE)
+ return llvm::None;
+
+ FileID FID = SourceMgr.getOrCreateFileID(FE, SrcMgr::C_User);
+
+ SourceLocation LocStart = SourceMgr.getComposedLoc(FID, OffsetStart);
+ SourceLocation LocEnd = SourceMgr.getComposedLoc(FID, OffsetEnd);
+ if (LocStart.isInvalid() || LocEnd.isInvalid())
+ return llvm::None;
+
+ Position Begin = sourceLocToPosition(SourceMgr, LocStart);
+ Position End = sourceLocToPosition(SourceMgr, LocEnd);
+ Location L;
+ L.uri = URIForFile(FilePath.str());
+ L.range = {Begin, End};
+ return L;
+}
+
+} // namespace
+
+llvm::Expected<std::vector<SymbolInformation>>
+getWorkspaceSymbols(StringRef Query, const WorkspaceSymbolOptions &Opts,
+ const SymbolIndex *const Index,
+ IntrusiveRefCntPtr<vfs::FileSystem> VFS,
+ const DraftStore &DS) {
+ std::vector<SymbolInformation> Result;
+ if (Query.empty() || !Index)
+ return Result;
+
+ // We'll use a temporary SourceManager to do the offset -> line/col mapping.
+ // We don't have any context from which this query was launched (working dir),
+ // so use defaults here.
+ // FIXME: If the index stored line/col directly, we woudln't have to read all
+ // the files here.
+ FileSystemOptions FileOpts;
+ FileManager FM(FileOpts, VFS);
+ IntrusiveRefCntPtr<DiagnosticsEngine> DE(
+ CompilerInstance::createDiagnostics(new DiagnosticOptions));
+ SourceManager TempSM(*DE, FM);
+
+ auto Names = splitQualifiedName(Query);
+
+ FuzzyFindRequest Req;
+ Req.Query = Names.second;
+
+ // FuzzyFind doesn't want leading :: qualifier
+ bool IsGlobalQuery = Names.first.consume_front("::");
+ // Restrict results to the scope in the query string if present (global or
+ // not).
+ if (IsGlobalQuery || !Names.first.empty())
+ Req.Scopes = {Names.first};
+ if (Opts.Limit)
+ Req.MaxCandidateCount = Opts.Limit;
+ Index->fuzzyFind(Req, [&DS, &TempSM, &Result](const Symbol &Sym) {
+ // Prefer the definition over e.g. a function declaration in a header
+ auto &CD = Sym.Definition ? Sym.Definition : Sym.CanonicalDeclaration;
+ auto Uri = URI::parse(CD.FileURI);
+ if (!Uri) {
+ log(llvm::formatv(
+ "Workspace symbol: Could not parse URI '{0}' for symbol '{1}'.",
+ CD.FileURI, Sym.Name));
+ return;
+ }
+ auto Path = URI::resolve(*Uri);
+ if (!Path) {
+ log(llvm::formatv("Workspace symbol: Could not resolve path for URI "
+ "'{0}' for symbol '{1}'.",
+ (*Uri).toString(), Sym.Name.str()));
+ return;
+ }
+ if (auto L =
+ makeLocation(DS, TempSM, *Path, CD.StartOffset, CD.StartOffset)) {
+ SymbolKind SK = indexSymbolKindToSymbolKind(Sym.SymInfo.Kind);
+ std::string Scope = Sym.Scope;
+ StringRef ScopeRef = Scope;
+ ScopeRef.consume_back("::");
+ Result.push_back({Sym.Name, SK, *L, ScopeRef});
+ }
+ });
+ return Result;
+}
+
+} // namespace clangd
+} // namespace clang
Index: clangd/ClangdServer.h
===================================================================
--- clangd/ClangdServer.h
+++ clangd/ClangdServer.h
@@ -33,6 +33,8 @@
class PCHContainerOperations;
namespace clangd {
+class DraftStore;
+struct WorkspaceSymbolOptions;
class DiagnosticsConsumer {
public:
@@ -157,6 +159,12 @@
/// Get code hover for a given position.
void findHover(PathRef File, Position Pos, Callback<Hover> CB);
+ /// Retrieve the top symbols from the workspace matching a query.
+ void workspaceSymbols(StringRef Query,
+ const clangd::WorkspaceSymbolOptions &Opts,
+ const DraftStore &DS,
+ Callback<std::vector<SymbolInformation>> CB);
+
/// Run formatting for \p Rng inside \p File with content \p Code.
llvm::Expected<tooling::Replacements> formatRange(StringRef Code,
PathRef File, Range Rng);
Index: clangd/ClangdServer.cpp
===================================================================
--- clangd/ClangdServer.cpp
+++ clangd/ClangdServer.cpp
@@ -9,6 +9,7 @@
#include "ClangdServer.h"
#include "CodeComplete.h"
+#include "FindSymbols.h"
#include "Headers.h"
#include "SourceCode.h"
#include "XRefs.h"
@@ -492,6 +493,13 @@
// invalidating other caches.
}
+void ClangdServer::workspaceSymbols(
+ StringRef Query, const clangd::WorkspaceSymbolOptions &Opts,
+ const DraftStore &DS, Callback<std::vector<SymbolInformation>> CB) {
+ CB(clangd::getWorkspaceSymbols(Query, Opts, Index, FSProvider.getFileSystem(),
+ DS));
+}
+
std::vector<std::pair<Path, std::size_t>>
ClangdServer::getUsedBytesPerFile() const {
return WorkScheduler.getUsedBytesPerFile();
Index: clangd/ClangdLSPServer.h
===================================================================
--- clangd/ClangdLSPServer.h
+++ clangd/ClangdLSPServer.h
@@ -12,6 +12,7 @@
#include "ClangdServer.h"
#include "DraftStore.h"
+#include "FindSymbols.h"
#include "GlobalCompilationDatabase.h"
#include "Path.h"
#include "Protocol.h"
@@ -33,6 +34,7 @@
/// loaded only from \p CompileCommandsDir. Otherwise, clangd will look
/// for compile_commands.json in all parent directories of each file.
ClangdLSPServer(JSONOutput &Out, const clangd::CodeCompleteOptions &CCOpts,
+ const clangd::WorkspaceSymbolOptions &WorkspaceSymOpts,
llvm::Optional<Path> CompileCommandsDir,
const ClangdServer::Options &Opts);
@@ -69,6 +71,7 @@
void onDocumentHighlight(TextDocumentPositionParams &Params) override;
void onFileEvent(DidChangeWatchedFilesParams &Params) override;
void onCommand(ExecuteCommandParams &Params) override;
+ void onWorkspaceSymbol(WorkspaceSymbolParams &Params) override;
void onRename(RenameParams &Parames) override;
void onHover(TextDocumentPositionParams &Params) override;
void onChangeConfiguration(DidChangeConfigurationParams &Params) override;
@@ -102,6 +105,10 @@
RealFileSystemProvider FSProvider;
/// Options used for code completion
clangd::CodeCompleteOptions CCOpts;
+ /// The support kinds of the client.
+ SymbolKindBitset SupportedSymbolKinds;
+ /// Options used for workspace symbol.
+ clangd::WorkspaceSymbolOptions WorkspaceSymbolOpts;
// Store of the current versions of the open documents.
DraftStore DraftMgr;
Index: clangd/ClangdLSPServer.cpp
===================================================================
--- clangd/ClangdLSPServer.cpp
+++ clangd/ClangdLSPServer.cpp
@@ -97,6 +97,21 @@
CCOpts.EnableSnippets =
Params.capabilities.textDocument.completion.completionItem.snippetSupport;
+ // All clients should support those.
+ for (SymKindUnderlyingType I = SymbolKindMin;
+ I <= static_cast<SymKindUnderlyingType>(SymbolKind::Array); ++I)
+ SupportedSymbolKinds.set(I);
+
+ if (Params.capabilities.workspace && Params.capabilities.workspace->symbol &&
+ Params.capabilities.workspace->symbol->symbolKind) {
+ for (SymbolKind Kind :
+ *Params.capabilities.workspace->symbol->symbolKind->valueSet) {
+ auto KindVal = static_cast<SymKindUnderlyingType>(Kind);
+ if (KindVal >= SymbolKindMin && KindVal <= SymbolKindMax)
+ SupportedSymbolKinds.set(KindVal);
+ }
+ }
+
reply(json::obj{
{{"capabilities",
json::obj{
@@ -122,6 +137,7 @@
{"documentHighlightProvider", true},
{"hoverProvider", true},
{"renameProvider", true},
+ {"workspaceSymbolProvider", true},
{"executeCommandProvider",
json::obj{
{"commands",
@@ -245,6 +261,28 @@
}
}
+void ClangdLSPServer::onWorkspaceSymbol(WorkspaceSymbolParams &Params) {
+ Server.workspaceSymbols(
+ Params.query, WorkspaceSymbolOpts, DraftMgr,
+ [this](llvm::Expected<std::vector<SymbolInformation>> Items) {
+ if (!Items)
+ return replyError(ErrorCode::InternalError,
+ llvm::toString(Items.takeError()));
+ for (auto &Sym : *Items) {
+ Sym.kind = adjustKindToCapability(Sym.kind, SupportedSymbolKinds);
+ assert(static_cast<SymKindUnderlyingType>(Sym.kind) >=
+ SymbolKindMin &&
+ static_cast<SymKindUnderlyingType>(Sym.kind) <
+ SupportedSymbolKinds.size() &&
+ SupportedSymbolKinds.test(
+ static_cast<SymKindUnderlyingType>(Sym.kind)) &&
+ "Unsupported symbol kind");
+ }
+
+ reply(json::ary(*Items));
+ });
+}
+
void ClangdLSPServer::onRename(RenameParams &Params) {
Path File = Params.textDocument.uri.file();
llvm::Optional<std::string> Code = DraftMgr.getDraft(File);
@@ -417,11 +455,12 @@
}
}
-ClangdLSPServer::ClangdLSPServer(JSONOutput &Out,
- const clangd::CodeCompleteOptions &CCOpts,
- llvm::Optional<Path> CompileCommandsDir,
- const ClangdServer::Options &Opts)
+ClangdLSPServer::ClangdLSPServer(
+ JSONOutput &Out, const clangd::CodeCompleteOptions &CCOpts,
+ const clangd::WorkspaceSymbolOptions &WorkspaceSymOpts,
+ llvm::Optional<Path> CompileCommandsDir, const ClangdServer::Options &Opts)
: Out(Out), CDB(std::move(CompileCommandsDir)), CCOpts(CCOpts),
+ WorkspaceSymbolOpts(WorkspaceSymOpts),
Server(CDB, FSProvider, /*DiagConsumer=*/*this, Opts) {}
bool ClangdLSPServer::run(std::istream &In, JSONStreamStyle InputStyle) {
Index: clangd/CMakeLists.txt
===================================================================
--- clangd/CMakeLists.txt
+++ clangd/CMakeLists.txt
@@ -19,6 +19,7 @@
Context.cpp
Diagnostics.cpp
DraftStore.cpp
+ FindSymbols.cpp
FuzzyMatch.cpp
GlobalCompilationDatabase.cpp
Headers.cpp
_______________________________________________
cfe-commits mailing list
[email protected]
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
