[clang-tools-extra] 6ef1cce - [clangd] Rename DiagnosticsConsumer -> ClangdServer::Callbacks, and make it optional
Sam McCall via cfe-commits
cfe-commits at lists.llvm.org
Fri Jan 24 06:59:42 PST 2020
Author: Sam McCall
Date: 2020-01-24T15:59:32+01:00
New Revision: 6ef1ccecf7aea94fb38fc8d891f0097829b9228e
URL: https://github.com/llvm/llvm-project/commit/6ef1ccecf7aea94fb38fc8d891f0097829b9228e
DIFF: https://github.com/llvm/llvm-project/commit/6ef1ccecf7aea94fb38fc8d891f0097829b9228e.diff
LOG: [clangd] Rename DiagnosticsConsumer -> ClangdServer::Callbacks, and make it optional
Summary:
This reflects its current function better and avoids confusion with clang::DiagnosticConsumer.
The old name/constructor is left around temporarily for compatibility.
(Metagame: merging with out-of-tree changes is harder than usual this month)
Reviewers: hokein
Subscribers: ilya-biryukov, javed.absar, MaskRay, jkorous, arphaman, kadircet, usaxena95, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D73346
Added:
Modified:
clang-tools-extra/clangd/ClangdLSPServer.cpp
clang-tools-extra/clangd/ClangdLSPServer.h
clang-tools-extra/clangd/ClangdServer.cpp
clang-tools-extra/clangd/ClangdServer.h
clang-tools-extra/clangd/unittests/ClangdTests.cpp
clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp
clang-tools-extra/clangd/unittests/FindSymbolsTests.cpp
clang-tools-extra/clangd/unittests/HeaderSourceSwitchTests.cpp
clang-tools-extra/clangd/unittests/RenameTests.cpp
clang-tools-extra/clangd/unittests/SemanticHighlightingTests.cpp
clang-tools-extra/clangd/unittests/SemanticSelectionTests.cpp
clang-tools-extra/clangd/unittests/TUSchedulerTests.cpp
clang-tools-extra/clangd/unittests/XRefsTests.cpp
Removed:
################################################################################
diff --git a/clang-tools-extra/clangd/ClangdLSPServer.cpp b/clang-tools-extra/clangd/ClangdLSPServer.cpp
index 633c61e681f9..0f87a81227a9 100644
--- a/clang-tools-extra/clangd/ClangdLSPServer.cpp
+++ b/clang-tools-extra/clangd/ClangdLSPServer.cpp
@@ -500,8 +500,8 @@ void ClangdLSPServer::onInitialize(const InitializeParams &Params,
if (NegotiatedOffsetEncoding)
WithOffsetEncoding.emplace(kCurrentOffsetEncoding,
*NegotiatedOffsetEncoding);
- Server.emplace(*CDB, FSProvider, static_cast<DiagnosticsConsumer &>(*this),
- ClangdServerOpts);
+ Server.emplace(*CDB, FSProvider, ClangdServerOpts,
+ static_cast<ClangdServer::Callbacks *>(this));
}
applyConfiguration(Params.initializationOptions.ConfigSettings);
diff --git a/clang-tools-extra/clangd/ClangdLSPServer.h b/clang-tools-extra/clangd/ClangdLSPServer.h
index 82fc49a66d06..c436f7114610 100644
--- a/clang-tools-extra/clangd/ClangdLSPServer.h
+++ b/clang-tools-extra/clangd/ClangdLSPServer.h
@@ -32,7 +32,7 @@ class SymbolIndex;
/// MessageHandler binds the implemented LSP methods (e.g. onInitialize) to
/// corresponding JSON-RPC methods ("initialize").
/// The server also supports $/cancelRequest (MessageHandler provides this).
-class ClangdLSPServer : private DiagnosticsConsumer {
+class ClangdLSPServer : private ClangdServer::Callbacks {
public:
/// If \p CompileCommandsDir has a value, compile_commands.json will be
/// loaded only from \p CompileCommandsDir. Otherwise, clangd will look
@@ -54,7 +54,7 @@ class ClangdLSPServer : private DiagnosticsConsumer {
bool run();
private:
- // Implement DiagnosticsConsumer.
+ // Implement ClangdServer::Callbacks.
void onDiagnosticsReady(PathRef File, std::vector<Diag> Diagnostics) override;
void onFileUpdated(PathRef File, const TUStatus &Status) override;
void
diff --git a/clang-tools-extra/clangd/ClangdServer.cpp b/clang-tools-extra/clangd/ClangdServer.cpp
index fb02c1371ed3..fd2aded40614 100644
--- a/clang-tools-extra/clangd/ClangdServer.cpp
+++ b/clang-tools-extra/clangd/ClangdServer.cpp
@@ -56,9 +56,10 @@ namespace {
// Update the FileIndex with new ASTs and plumb the diagnostics responses.
struct UpdateIndexCallbacks : public ParsingCallbacks {
- UpdateIndexCallbacks(FileIndex *FIndex, DiagnosticsConsumer &DiagConsumer,
+ UpdateIndexCallbacks(FileIndex *FIndex,
+ ClangdServer::Callbacks *ServerCallbacks,
bool SemanticHighlighting)
- : FIndex(FIndex), DiagConsumer(DiagConsumer),
+ : FIndex(FIndex), ServerCallbacks(ServerCallbacks),
SemanticHighlighting(SemanticHighlighting) {}
void onPreambleAST(PathRef Path, ASTContext &Ctx,
@@ -77,25 +78,28 @@ struct UpdateIndexCallbacks : public ParsingCallbacks {
if (SemanticHighlighting)
Highlightings = getSemanticHighlightings(AST);
- Publish([&]() {
- DiagConsumer.onDiagnosticsReady(Path, std::move(Diagnostics));
- if (SemanticHighlighting)
- DiagConsumer.onHighlightingsReady(Path, std::move(Highlightings));
- });
+ if (ServerCallbacks)
+ Publish([&]() {
+ ServerCallbacks->onDiagnosticsReady(Path, std::move(Diagnostics));
+ if (SemanticHighlighting)
+ ServerCallbacks->onHighlightingsReady(Path, std::move(Highlightings));
+ });
}
void onFailedAST(PathRef Path, std::vector<Diag> Diags,
PublishFn Publish) override {
- Publish([&]() { DiagConsumer.onDiagnosticsReady(Path, Diags); });
+ if (ServerCallbacks)
+ Publish([&]() { ServerCallbacks->onDiagnosticsReady(Path, Diags); });
}
void onFileUpdated(PathRef File, const TUStatus &Status) override {
- DiagConsumer.onFileUpdated(File, Status);
+ if (ServerCallbacks)
+ ServerCallbacks->onFileUpdated(File, Status);
}
private:
FileIndex *FIndex;
- DiagnosticsConsumer &DiagConsumer;
+ ClangdServer::Callbacks *ServerCallbacks;
bool SemanticHighlighting;
};
} // namespace
@@ -111,8 +115,7 @@ ClangdServer::Options ClangdServer::optsForTest() {
ClangdServer::ClangdServer(const GlobalCompilationDatabase &CDB,
const FileSystemProvider &FSProvider,
- DiagnosticsConsumer &DiagConsumer,
- const Options &Opts)
+ const Options &Opts, Callbacks *Callbacks)
: FSProvider(FSProvider),
DynamicIdx(Opts.BuildDynamicSymbolIndex
? new FileIndex(Opts.HeavyweightDynamicSymbolIndex)
@@ -126,11 +129,10 @@ ClangdServer::ClangdServer(const GlobalCompilationDatabase &CDB,
// is parsed.
// FIXME(ioeric): this can be slow and we may be able to index on less
// critical paths.
- WorkScheduler(
- CDB, Opts.AsyncThreadsCount, Opts.StorePreamblesInMemory,
- std::make_unique<UpdateIndexCallbacks>(DynamicIdx.get(), DiagConsumer,
- Opts.SemanticHighlighting),
- Opts.UpdateDebounce, Opts.RetentionPolicy) {
+ WorkScheduler(CDB, Opts.AsyncThreadsCount, Opts.StorePreamblesInMemory,
+ std::make_unique<UpdateIndexCallbacks>(
+ DynamicIdx.get(), Callbacks, Opts.SemanticHighlighting),
+ Opts.UpdateDebounce, Opts.RetentionPolicy) {
// Adds an index to the stack, at higher priority than existing indexes.
auto AddIndex = [&](SymbolIndex *Idx) {
if (this->Index != nullptr) {
@@ -148,8 +150,9 @@ ClangdServer::ClangdServer(const GlobalCompilationDatabase &CDB,
BackgroundIndexStorage::createDiskBackedStorageFactory(
[&CDB](llvm::StringRef File) { return CDB.getProjectInfo(File); }),
std::max(Opts.AsyncThreadsCount, 1u),
- [&DiagConsumer](BackgroundQueue::Stats S) {
- DiagConsumer.onBackgroundIndexProgress(S);
+ [Callbacks](BackgroundQueue::Stats S) {
+ if (Callbacks)
+ Callbacks->onBackgroundIndexProgress(S);
});
AddIndex(BackgroundIdx.get());
}
diff --git a/clang-tools-extra/clangd/ClangdServer.h b/clang-tools-extra/clangd/ClangdServer.h
index 142ca9bc507f..2bcf5ed775a4 100644
--- a/clang-tools-extra/clangd/ClangdServer.h
+++ b/clang-tools-extra/clangd/ClangdServer.h
@@ -41,26 +41,6 @@
namespace clang {
namespace clangd {
-// FIXME: find a better name.
-class DiagnosticsConsumer {
-public:
- virtual ~DiagnosticsConsumer() = default;
-
- /// Called by ClangdServer when \p Diagnostics for \p File are ready.
- virtual void onDiagnosticsReady(PathRef File,
- std::vector<Diag> Diagnostics) = 0;
- /// Called whenever the file status is updated.
- virtual void onFileUpdated(PathRef File, const TUStatus &Status){};
-
- /// Called by ClangdServer when some \p Highlightings for \p File are ready.
- virtual void
- onHighlightingsReady(PathRef File,
- std::vector<HighlightingToken> Highlightings) {}
-
- // Called when background indexing tasks are enqueued, started, or completed.
- virtual void onBackgroundIndexProgress(const BackgroundQueue::Stats &Stats) {}
-};
-
/// When set, used by ClangdServer to get clang-tidy options for each particular
/// file. Must be thread-safe. We use this instead of ClangTidyOptionsProvider
/// to allow reading tidy configs from the VFS used for parsing.
@@ -82,6 +62,31 @@ using ClangTidyOptionsBuilder = std::function<tidy::ClangTidyOptions(
/// (ClangdLSPServer uses this to implement $/cancelRequest).
class ClangdServer {
public:
+ /// Interface with hooks for users of ClangdServer to be notified of events.
+ class Callbacks {
+ public:
+ virtual ~Callbacks() = default;
+
+ /// Called by ClangdServer when \p Diagnostics for \p File are ready.
+ /// May be called concurrently for separate files, not for a single file.
+ virtual void onDiagnosticsReady(PathRef File,
+ std::vector<Diag> Diagnostics) {}
+ /// Called whenever the file status is updated.
+ /// May be called concurrently for separate files, not for a single file.
+ virtual void onFileUpdated(PathRef File, const TUStatus &Status){};
+
+ /// Called by ClangdServer when some \p Highlightings for \p File are ready.
+ /// May be called concurrently for separate files, not for a single file.
+ virtual void
+ onHighlightingsReady(PathRef File,
+ std::vector<HighlightingToken> Highlightings) {}
+
+ /// Called when background indexing tasks are enqueued/started/completed.
+ /// Not called concurrently.
+ virtual void
+ onBackgroundIndexProgress(const BackgroundQueue::Stats &Stats) {}
+ };
+
struct Options {
/// To process requests asynchronously, ClangdServer spawns worker threads.
/// If this is zero, no threads are spawned. All work is done on the calling
@@ -156,14 +161,15 @@ class ClangdServer {
/// added file (i.e., when processing a first call to addDocument) and reuses
/// those arguments for subsequent reparses. However, ClangdServer will check
/// if compilation arguments changed on calls to forceReparse().
- ///
- /// After each parsing request finishes, ClangdServer reports diagnostics to
- /// \p DiagConsumer. Note that a callback to \p DiagConsumer happens on a
- /// worker thread. Therefore, instances of \p DiagConsumer must properly
- /// synchronize access to shared state.
ClangdServer(const GlobalCompilationDatabase &CDB,
- const FileSystemProvider &FSProvider,
- DiagnosticsConsumer &DiagConsumer, const Options &Opts);
+ const FileSystemProvider &FSProvider, const Options &Opts,
+ Callbacks *Callbacks = nullptr);
+
+ // FIXME: remove this compatibility alias.
+ ClangdServer(const GlobalCompilationDatabase &CDB,
+ const FileSystemProvider &FSProvider, Callbacks &Callbacks,
+ const Options &Opts)
+ : ClangdServer(CDB, FSProvider, Opts, &Callbacks) {}
/// Add a \p File to the list of tracked C++ files or update the contents if
/// \p File is already tracked. Also schedules parsing of the AST for it on a
@@ -353,6 +359,9 @@ class ClangdServer {
TUScheduler WorkScheduler;
};
+// FIXME: Remove this compatibility alias.
+using DiagnosticsConsumer = ClangdServer::Callbacks;
+
} // namespace clangd
} // namespace clang
diff --git a/clang-tools-extra/clangd/unittests/ClangdTests.cpp b/clang-tools-extra/clangd/unittests/ClangdTests.cpp
index ab88c8925da0..fbc6e6463732 100644
--- a/clang-tools-extra/clangd/unittests/ClangdTests.cpp
+++ b/clang-tools-extra/clangd/unittests/ClangdTests.cpp
@@ -59,7 +59,7 @@ bool diagsContainErrors(const std::vector<Diag> &Diagnostics) {
return false;
}
-class ErrorCheckingDiagConsumer : public DiagnosticsConsumer {
+class ErrorCheckingCallbacks : public ClangdServer::Callbacks {
public:
void onDiagnosticsReady(PathRef File,
std::vector<Diag> Diagnostics) override {
@@ -80,7 +80,7 @@ class ErrorCheckingDiagConsumer : public DiagnosticsConsumer {
/// For each file, record whether the last published diagnostics contained at
/// least one error.
-class MultipleErrorCheckingDiagConsumer : public DiagnosticsConsumer {
+class MultipleErrorCheckingCallbacks : public ClangdServer::Callbacks {
public:
void onDiagnosticsReady(PathRef File,
std::vector<Diag> Diagnostics) override {
@@ -142,9 +142,9 @@ class ClangdVFSTest : public ::testing::Test {
std::vector<std::pair<PathRef, llvm::StringRef>> ExtraFiles = {},
bool ExpectErrors = false) {
MockFSProvider FS;
- ErrorCheckingDiagConsumer DiagConsumer;
+ ErrorCheckingCallbacks DiagConsumer;
MockCompilationDatabase CDB;
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &DiagConsumer);
for (const auto &FileWithContents : ExtraFiles)
FS.Files[testPath(FileWithContents.first)] = FileWithContents.second;
@@ -194,9 +194,9 @@ int b = a;
TEST_F(ClangdVFSTest, Reparse) {
MockFSProvider FS;
- ErrorCheckingDiagConsumer DiagConsumer;
+ ErrorCheckingCallbacks DiagConsumer;
MockCompilationDatabase CDB;
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &DiagConsumer);
const auto SourceContents = R"cpp(
#include "foo.h"
@@ -229,9 +229,9 @@ int b = a;
TEST_F(ClangdVFSTest, ReparseOnHeaderChange) {
MockFSProvider FS;
- ErrorCheckingDiagConsumer DiagConsumer;
+ ErrorCheckingCallbacks DiagConsumer;
MockCompilationDatabase CDB;
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &DiagConsumer);
const auto SourceContents = R"cpp(
#include "foo.h"
@@ -274,24 +274,24 @@ TEST_F(ClangdVFSTest, PropagatesContexts) {
}
mutable int Got;
} FS;
- struct DiagConsumer : public DiagnosticsConsumer {
+ struct Callbacks : public ClangdServer::Callbacks {
void onDiagnosticsReady(PathRef File,
std::vector<Diag> Diagnostics) override {
Got = Context::current().getExisting(Secret);
}
int Got;
- } DiagConsumer;
+ } Callbacks;
MockCompilationDatabase CDB;
// Verify that the context is plumbed to the FS provider and diagnostics.
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &Callbacks);
{
WithContextValue Entrypoint(Secret, 42);
Server.addDocument(testPath("foo.cpp"), "void main(){}");
}
ASSERT_TRUE(Server.blockUntilIdleForTest());
EXPECT_EQ(FS.Got, 42);
- EXPECT_EQ(DiagConsumer.Got, 42);
+ EXPECT_EQ(Callbacks.Got, 42);
}
// Only enable this test on Unix
@@ -299,13 +299,13 @@ TEST_F(ClangdVFSTest, PropagatesContexts) {
TEST_F(ClangdVFSTest, SearchLibDir) {
// Checks that searches for GCC installation is done through vfs.
MockFSProvider FS;
- ErrorCheckingDiagConsumer DiagConsumer;
+ ErrorCheckingCallbacks DiagConsumer;
MockCompilationDatabase CDB;
CDB.ExtraClangFlags.insert(CDB.ExtraClangFlags.end(),
{"-xc++", "-target", "x86_64-linux-unknown",
"-m64", "--gcc-toolchain=/randomusr",
"-stdlib=libstdc++"});
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &DiagConsumer);
// Just a random gcc version string
SmallString<8> Version("4.9.3");
@@ -348,9 +348,9 @@ std::string x;
TEST_F(ClangdVFSTest, ForceReparseCompileCommand) {
MockFSProvider FS;
- ErrorCheckingDiagConsumer DiagConsumer;
+ ErrorCheckingCallbacks DiagConsumer;
MockCompilationDatabase CDB;
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &DiagConsumer);
auto FooCpp = testPath("foo.cpp");
const auto SourceContents1 = R"cpp(
@@ -384,9 +384,9 @@ struct bar { T x; };
TEST_F(ClangdVFSTest, ForceReparseCompileCommandDefines) {
MockFSProvider FS;
- ErrorCheckingDiagConsumer DiagConsumer;
+ ErrorCheckingCallbacks DiagConsumer;
MockCompilationDatabase CDB;
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &DiagConsumer);
auto FooCpp = testPath("foo.cpp");
const auto SourceContents = R"cpp(
@@ -437,8 +437,8 @@ int hello;
MockFSProvider FS;
MockCompilationDatabase CDB;
- MultipleErrorCheckingDiagConsumer DiagConsumer;
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ MultipleErrorCheckingCallbacks DiagConsumer;
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &DiagConsumer);
auto FooCpp = testPath("foo.cpp");
auto BarCpp = testPath("bar.cpp");
@@ -480,9 +480,9 @@ int hello;
TEST_F(ClangdVFSTest, MemoryUsage) {
MockFSProvider FS;
- ErrorCheckingDiagConsumer DiagConsumer;
+ ErrorCheckingCallbacks DiagConsumer;
MockCompilationDatabase CDB;
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &DiagConsumer);
Path FooCpp = testPath("foo.cpp");
const auto SourceContents = R"cpp(
@@ -515,10 +515,10 @@ struct Something {
TEST_F(ClangdVFSTest, InvalidCompileCommand) {
MockFSProvider FS;
- ErrorCheckingDiagConsumer DiagConsumer;
+ ErrorCheckingCallbacks DiagConsumer;
MockCompilationDatabase CDB;
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &DiagConsumer);
auto FooCpp = testPath("foo.cpp");
// clang cannot create CompilerInvocation if we pass two files in the
@@ -589,7 +589,7 @@ int d;
bool HadErrorsInLastDiags = false;
};
- class TestDiagConsumer : public DiagnosticsConsumer {
+ class TestDiagConsumer : public ClangdServer::Callbacks {
public:
TestDiagConsumer() : Stats(FilesCount, FileStat()) {}
@@ -635,7 +635,7 @@ int d;
TestDiagConsumer DiagConsumer;
{
MockCompilationDatabase CDB;
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &DiagConsumer);
// Prepare some random distributions for the test.
std::random_device RandGen;
@@ -766,7 +766,7 @@ int d;
}
TEST_F(ClangdThreadingTest, NoConcurrentDiagnostics) {
- class NoConcurrentAccessDiagConsumer : public DiagnosticsConsumer {
+ class NoConcurrentAccessDiagConsumer : public ClangdServer::Callbacks {
public:
std::atomic<int> Count = {0};
@@ -818,7 +818,7 @@ int d;
NoConcurrentAccessDiagConsumer DiagConsumer(std::move(StartSecondPromise));
MockCompilationDatabase CDB;
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &DiagConsumer);
Server.addDocument(FooCpp, SourceContentsWithErrors);
StartSecond.wait();
Server.addDocument(FooCpp, SourceContentsWithoutErrors);
@@ -828,9 +828,9 @@ int d;
TEST_F(ClangdVFSTest, FormatCode) {
MockFSProvider FS;
- ErrorCheckingDiagConsumer DiagConsumer;
+ ErrorCheckingCallbacks DiagConsumer;
MockCompilationDatabase CDB;
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &DiagConsumer);
auto Path = testPath("foo.cpp");
std::string Code = R"cpp(
@@ -857,9 +857,9 @@ void f() {}
TEST_F(ClangdVFSTest, ChangedHeaderFromISystem) {
MockFSProvider FS;
- ErrorCheckingDiagConsumer DiagConsumer;
+ ErrorCheckingCallbacks DiagConsumer;
MockCompilationDatabase CDB;
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &DiagConsumer);
auto SourcePath = testPath("source/foo.cpp");
auto HeaderPath = testPath("headers/foo.h");
@@ -932,9 +932,9 @@ TEST(ClangdTests, PreambleVFSStatCache) {
llvm::StringMap<unsigned> CountStats;
ListenStatsFSProvider FS(CountStats);
- ErrorCheckingDiagConsumer DiagConsumer;
+ ErrorCheckingCallbacks DiagConsumer;
MockCompilationDatabase CDB;
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &DiagConsumer);
auto SourcePath = testPath("foo.cpp");
auto HeaderPath = testPath("foo.h");
@@ -961,9 +961,9 @@ TEST(ClangdTests, PreambleVFSStatCache) {
TEST_F(ClangdVFSTest, FallbackWhenPreambleIsNotReady) {
MockFSProvider FS;
- ErrorCheckingDiagConsumer DiagConsumer;
+ ErrorCheckingCallbacks DiagConsumer;
MockCompilationDatabase CDB;
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &DiagConsumer);
auto FooCpp = testPath("foo.cpp");
Annotations Code(R"cpp(
@@ -1007,7 +1007,7 @@ TEST_F(ClangdVFSTest, FallbackWhenPreambleIsNotReady) {
TEST_F(ClangdVFSTest, FallbackWhenWaitingForCompileCommand) {
MockFSProvider FS;
- ErrorCheckingDiagConsumer DiagConsumer;
+ ErrorCheckingCallbacks DiagConsumer;
// Returns compile command only when notified.
class DelayedCompilationDatabase : public GlobalCompilationDatabase {
public:
@@ -1033,7 +1033,7 @@ TEST_F(ClangdVFSTest, FallbackWhenWaitingForCompileCommand) {
Notification CanReturnCommand;
DelayedCompilationDatabase CDB(CanReturnCommand);
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &DiagConsumer);
auto FooCpp = testPath("foo.cpp");
Annotations Code(R"cpp(
diff --git a/clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp b/clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp
index d76508834efd..b055d1c6b54d 100644
--- a/clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp
+++ b/clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp
@@ -45,11 +45,6 @@ using ::testing::IsEmpty;
using ::testing::Not;
using ::testing::UnorderedElementsAre;
-class IgnoreDiagnostics : public DiagnosticsConsumer {
- void onDiagnosticsReady(PathRef File,
- std::vector<Diag> Diagnostics) override {}
-};
-
// GMock helpers for matching completion items.
MATCHER_P(Named, Name, "") { return arg.Name == Name; }
MATCHER_P(NameStartsWith, Prefix, "") {
@@ -143,8 +138,7 @@ CodeCompleteResult completions(llvm::StringRef Text,
MockCompilationDatabase CDB;
// To make sure our tests for completiopns inside templates work on Windows.
CDB.ExtraClangFlags = {"-fno-delayed-template-parsing"};
- IgnoreDiagnostics DiagConsumer;
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest());
return completions(Server, Text, std::move(IndexSymbols), std::move(Opts),
FilePath);
}
@@ -670,8 +664,7 @@ TEST(CompletionTest, IncludeInsertionPreprocessorIntegrationTests) {
std::string BarHeader = testPath("sub/bar.h");
FS.Files[BarHeader] = "";
- IgnoreDiagnostics DiagConsumer;
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest());
auto BarURI = URI::create(BarHeader).toString();
Symbol Sym = cls("ns::X");
Sym.CanonicalDeclaration.FileURI = BarURI.c_str();
@@ -709,8 +702,7 @@ TEST(CompletionTest, NoIncludeInsertionWhenDeclFoundInFile) {
MockFSProvider FS;
MockCompilationDatabase CDB;
- IgnoreDiagnostics DiagConsumer;
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest());
Symbol SymX = cls("ns::X");
Symbol SymY = cls("ns::Y");
std::string BarHeader = testPath("bar.h");
@@ -737,8 +729,7 @@ TEST(CompletionTest, NoIncludeInsertionWhenDeclFoundInFile) {
TEST(CompletionTest, IndexSuppressesPreambleCompletions) {
MockFSProvider FS;
MockCompilationDatabase CDB;
- IgnoreDiagnostics DiagConsumer;
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest());
FS.Files[testPath("bar.h")] =
R"cpp(namespace ns { struct preamble { int member; }; })cpp";
@@ -787,10 +778,9 @@ TEST(CompletionTest, CompletionInPreamble) {
TEST(CompletionTest, DynamicIndexIncludeInsertion) {
MockFSProvider FS;
MockCompilationDatabase CDB;
- IgnoreDiagnostics DiagConsumer;
ClangdServer::Options Opts = ClangdServer::optsForTest();
Opts.BuildDynamicSymbolIndex = true;
- ClangdServer Server(CDB, FS, DiagConsumer, Opts);
+ ClangdServer Server(CDB, FS, Opts);
FS.Files[testPath("foo_header.h")] = R"cpp(
#pragma once
@@ -816,10 +806,9 @@ TEST(CompletionTest, DynamicIndexIncludeInsertion) {
TEST(CompletionTest, DynamicIndexMultiFile) {
MockFSProvider FS;
MockCompilationDatabase CDB;
- IgnoreDiagnostics DiagConsumer;
auto Opts = ClangdServer::optsForTest();
Opts.BuildDynamicSymbolIndex = true;
- ClangdServer Server(CDB, FS, DiagConsumer, Opts);
+ ClangdServer Server(CDB, FS, Opts);
FS.Files[testPath("foo.h")] = R"cpp(
namespace ns { class XYZ {}; void foo(int x) {} }
@@ -877,12 +866,11 @@ TEST(CompletionTest, Documentation) {
TEST(CompletionTest, CommentsFromSystemHeaders) {
MockFSProvider FS;
MockCompilationDatabase CDB;
- IgnoreDiagnostics DiagConsumer;
auto Opts = ClangdServer::optsForTest();
Opts.BuildDynamicSymbolIndex = true;
- ClangdServer Server(CDB, FS, DiagConsumer, Opts);
+ ClangdServer Server(CDB, FS, Opts);
FS.Files[testPath("foo.h")] = R"cpp(
#pragma GCC system_header
@@ -1050,11 +1038,10 @@ SignatureHelp signatures(llvm::StringRef Text, Position Point,
MockFSProvider FS;
MockCompilationDatabase CDB;
- IgnoreDiagnostics DiagConsumer;
ClangdServer::Options Opts = ClangdServer::optsForTest();
Opts.StaticIndex = Index.get();
- ClangdServer Server(CDB, FS, DiagConsumer, Opts);
+ ClangdServer Server(CDB, FS, Opts);
auto File = testPath("foo.cpp");
runAddDocument(Server, File, Text);
return llvm::cantFail(runSignatureHelp(Server, File, Point));
@@ -1502,8 +1489,7 @@ TEST(CompletionTest, DocumentationFromChangedFileCrash) {
FS.Files[FooCpp] = "";
MockCompilationDatabase CDB;
- IgnoreDiagnostics DiagConsumer;
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest());
Annotations Source(R"cpp(
#include "foo.h"
@@ -1537,8 +1523,7 @@ TEST(CompletionTest, NonDocComments) {
FS.Files[FooCpp] = "";
MockCompilationDatabase CDB;
- IgnoreDiagnostics DiagConsumer;
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest());
Annotations Source(R"cpp(
// We ignore namespace comments, for rationale see CodeCompletionStrings.h.
@@ -1602,11 +1587,10 @@ TEST(CompletionTest, CompleteOnInvalidLine) {
auto FooCpp = testPath("foo.cpp");
MockCompilationDatabase CDB;
- IgnoreDiagnostics DiagConsumer;
MockFSProvider FS;
FS.Files[FooCpp] = "// empty file";
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest());
// Run completion outside the file range.
Position Pos;
Pos.line = 100;
@@ -1726,8 +1710,7 @@ TEST(CompletionTest, CodeCompletionContext) {
TEST(CompletionTest, FixItForArrowToDot) {
MockFSProvider FS;
MockCompilationDatabase CDB;
- IgnoreDiagnostics DiagConsumer;
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest());
CodeCompleteOptions Opts;
Opts.IncludeFixIts = true;
@@ -1766,8 +1749,7 @@ TEST(CompletionTest, FixItForArrowToDot) {
TEST(CompletionTest, FixItForDotToArrow) {
MockFSProvider FS;
MockCompilationDatabase CDB;
- IgnoreDiagnostics DiagConsumer;
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest());
CodeCompleteOptions Opts;
Opts.IncludeFixIts = true;
@@ -1846,8 +1828,7 @@ TEST(CompletionTest, RenderWithFixItNonMerged) {
TEST(CompletionTest, CompletionTokenRange) {
MockFSProvider FS;
MockCompilationDatabase CDB;
- IgnoreDiagnostics DiagConsumer;
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest());
constexpr const char *TestCodes[] = {
R"cpp(
@@ -2004,10 +1985,9 @@ TEST(SignatureHelpTest, IndexDocumentation) {
TEST(SignatureHelpTest, DynamicIndexDocumentation) {
MockFSProvider FS;
MockCompilationDatabase CDB;
- IgnoreDiagnostics DiagConsumer;
ClangdServer::Options Opts = ClangdServer::optsForTest();
Opts.BuildDynamicSymbolIndex = true;
- ClangdServer Server(CDB, FS, DiagConsumer, Opts);
+ ClangdServer Server(CDB, FS, Opts);
FS.Files[testPath("foo.h")] = R"cpp(
struct Foo {
@@ -2176,8 +2156,7 @@ TEST(GuessCompletionPrefix, Filters) {
TEST(CompletionTest, EnableSpeculativeIndexRequest) {
MockFSProvider FS;
MockCompilationDatabase CDB;
- IgnoreDiagnostics DiagConsumer;
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest());
auto File = testPath("foo.cpp");
Annotations Test(R"cpp(
@@ -2235,8 +2214,7 @@ TEST(CompletionTest, NoInsertIncludeIfOnePresent) {
std::string FooHeader = testPath("foo.h");
FS.Files[FooHeader] = "";
- IgnoreDiagnostics DiagConsumer;
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest());
std::string DeclFile = URI::create(testPath("foo")).toString();
Symbol Sym = func("Func");
@@ -2266,8 +2244,7 @@ TEST(CompletionTest, MacroFromPreamble) {
MockCompilationDatabase CDB;
std::string FooHeader = testPath("foo.h");
FS.Files[FooHeader] = "#define CLANGD_PREAMBLE_HEADER x\n";
- IgnoreDiagnostics DiagConsumer;
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest());
auto Results = completions(
R"cpp(#include "foo.h"
#define CLANGD_PREAMBLE_MAIN x
@@ -2396,8 +2373,7 @@ TEST(CompletionTest, IncludedCompletionKinds) {
CDB.ExtraClangFlags = {SearchDirArg.c_str()};
std::string BarHeader = testPath("sub/bar.h");
FS.Files[BarHeader] = "";
- IgnoreDiagnostics DiagConsumer;
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest());
auto Results = completions(Server,
R"cpp(
#include "^"
diff --git a/clang-tools-extra/clangd/unittests/FindSymbolsTests.cpp b/clang-tools-extra/clangd/unittests/FindSymbolsTests.cpp
index eba920a7a452..f2e67d0babc6 100644
--- a/clang-tools-extra/clangd/unittests/FindSymbolsTests.cpp
+++ b/clang-tools-extra/clangd/unittests/FindSymbolsTests.cpp
@@ -25,11 +25,6 @@ using ::testing::Field;
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(QName, Name, "") {
if (arg.containerName.empty())
@@ -56,8 +51,7 @@ ClangdServer::Options optsForTests() {
class WorkspaceSymbolsTest : public ::testing::Test {
public:
- WorkspaceSymbolsTest()
- : Server(CDB, FSProvider, DiagConsumer, optsForTests()) {
+ WorkspaceSymbolsTest() : Server(CDB, FSProvider, optsForTests()) {
// Make sure the test root directory is created.
FSProvider.Files[testPath("unused")] = "";
CDB.ExtraClangFlags = {"-xc++"};
@@ -66,7 +60,6 @@ class WorkspaceSymbolsTest : public ::testing::Test {
protected:
MockFSProvider FSProvider;
MockCompilationDatabase CDB;
- IgnoreDiagnostics DiagConsumer;
ClangdServer Server;
int Limit = 0;
@@ -316,13 +309,11 @@ TEST_F(WorkspaceSymbolsTest, TempSpecs) {
namespace {
class DocumentSymbolsTest : public ::testing::Test {
public:
- DocumentSymbolsTest()
- : Server(CDB, FSProvider, DiagConsumer, optsForTests()) {}
+ DocumentSymbolsTest() : Server(CDB, FSProvider, optsForTests()) {}
protected:
MockFSProvider FSProvider;
MockCompilationDatabase CDB;
- IgnoreDiagnostics DiagConsumer;
ClangdServer Server;
std::vector<DocumentSymbol> getSymbols(PathRef File) {
diff --git a/clang-tools-extra/clangd/unittests/HeaderSourceSwitchTests.cpp b/clang-tools-extra/clangd/unittests/HeaderSourceSwitchTests.cpp
index 19838af5903a..44ef40f9c99d 100644
--- a/clang-tools-extra/clangd/unittests/HeaderSourceSwitchTests.cpp
+++ b/clang-tools-extra/clangd/unittests/HeaderSourceSwitchTests.cpp
@@ -249,10 +249,6 @@ TEST(HeaderSourceSwitchTest, FromSourceToHeader) {
}
TEST(HeaderSourceSwitchTest, ClangdServerIntegration) {
- class IgnoreDiagnostics : public DiagnosticsConsumer {
- void onDiagnosticsReady(PathRef File,
- std::vector<Diag> Diagnostics) override {}
- } DiagConsumer;
MockCompilationDatabase CDB;
CDB.ExtraClangFlags = {"-I" +
testPath("src/include")}; // add search directory.
@@ -268,7 +264,7 @@ TEST(HeaderSourceSwitchTest, ClangdServerIntegration) {
FS.Files[CppPath] = FileContent;
auto Options = ClangdServer::optsForTest();
Options.BuildDynamicSymbolIndex = true;
- ClangdServer Server(CDB, FS, DiagConsumer, Options);
+ ClangdServer Server(CDB, FS, Options);
runAddDocument(Server, CppPath, FileContent);
EXPECT_EQ(HeaderPath,
*llvm::cantFail(runSwitchHeaderSource(Server, CppPath)));
diff --git a/clang-tools-extra/clangd/unittests/RenameTests.cpp b/clang-tools-extra/clangd/unittests/RenameTests.cpp
index 4f0054e8075f..6d62d1ee944b 100644
--- a/clang-tools-extra/clangd/unittests/RenameTests.cpp
+++ b/clang-tools-extra/clangd/unittests/RenameTests.cpp
@@ -755,10 +755,6 @@ TEST(CrossFileRenameTests, DeduplicateRefsFromIndex) {
TEST(CrossFileRenameTests, WithUpToDateIndex) {
MockCompilationDatabase CDB;
CDB.ExtraClangFlags = {"-xc++"};
- class IgnoreDiagnostics : public DiagnosticsConsumer {
- void onDiagnosticsReady(PathRef File,
- std::vector<Diag> Diagnostics) override {}
- } DiagConsumer;
// rename is runnning on all "^" points in FooH, and "[[]]" ranges are the
// expected rename occurrences.
struct Case {
@@ -902,7 +898,7 @@ TEST(CrossFileRenameTests, WithUpToDateIndex) {
auto ServerOpts = ClangdServer::optsForTest();
ServerOpts.CrossFileRename = true;
ServerOpts.BuildDynamicSymbolIndex = true;
- ClangdServer Server(CDB, FS, DiagConsumer, ServerOpts);
+ ClangdServer Server(CDB, FS, ServerOpts);
// Add all files to clangd server to make sure the dynamic index has been
// built.
diff --git a/clang-tools-extra/clangd/unittests/SemanticHighlightingTests.cpp b/clang-tools-extra/clangd/unittests/SemanticHighlightingTests.cpp
index baffc6afaff1..a74f75f5563b 100644
--- a/clang-tools-extra/clangd/unittests/SemanticHighlightingTests.cpp
+++ b/clang-tools-extra/clangd/unittests/SemanticHighlightingTests.cpp
@@ -696,11 +696,10 @@ sizeof...($TemplateParameter[[Elements]]);
}
TEST(SemanticHighlighting, GeneratesHighlightsWhenFileChange) {
- class HighlightingsCounterDiagConsumer : public DiagnosticsConsumer {
+ class HighlightingsCounter : public ClangdServer::Callbacks {
public:
std::atomic<int> Count = {0};
- void onDiagnosticsReady(PathRef, std::vector<Diag>) override {}
void onHighlightingsReady(
PathRef File, std::vector<HighlightingToken> Highlightings) override {
++Count;
@@ -712,11 +711,11 @@ TEST(SemanticHighlighting, GeneratesHighlightsWhenFileChange) {
FS.Files[FooCpp] = "";
MockCompilationDatabase MCD;
- HighlightingsCounterDiagConsumer DiagConsumer;
- ClangdServer Server(MCD, FS, DiagConsumer, ClangdServer::optsForTest());
+ HighlightingsCounter Counter;
+ ClangdServer Server(MCD, FS, ClangdServer::optsForTest(), &Counter);
Server.addDocument(FooCpp, "int a;");
ASSERT_TRUE(Server.blockUntilIdleForTest()) << "Waiting for server";
- ASSERT_EQ(DiagConsumer.Count, 1);
+ ASSERT_EQ(Counter.Count, 1);
}
TEST(SemanticHighlighting, toSemanticHighlightingInformation) {
diff --git a/clang-tools-extra/clangd/unittests/SemanticSelectionTests.cpp b/clang-tools-extra/clangd/unittests/SemanticSelectionTests.cpp
index f518fea67292..8f580f860a89 100644
--- a/clang-tools-extra/clangd/unittests/SemanticSelectionTests.cpp
+++ b/clang-tools-extra/clangd/unittests/SemanticSelectionTests.cpp
@@ -26,11 +26,6 @@ namespace clangd {
namespace {
using ::testing::ElementsAreArray;
-class IgnoreDiagnostics : public DiagnosticsConsumer {
- void onDiagnosticsReady(PathRef File,
- std::vector<Diag> Diagnostics) override {}
-};
-
TEST(SemanticSelection, All) {
const char *Tests[] = {
R"cpp( // Single statement in a function body.
@@ -146,9 +141,8 @@ TEST(SemanticSelection, All) {
TEST(SemanticSelection, RunViaClangDServer) {
MockFSProvider FS;
- IgnoreDiagnostics DiagConsumer;
MockCompilationDatabase CDB;
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest());
auto FooH = testPath("foo.h");
FS.Files[FooH] = R"cpp(
diff --git a/clang-tools-extra/clangd/unittests/TUSchedulerTests.cpp b/clang-tools-extra/clangd/unittests/TUSchedulerTests.cpp
index 1203f3e6e5c7..5b8085e9ae1d 100644
--- a/clang-tools-extra/clangd/unittests/TUSchedulerTests.cpp
+++ b/clang-tools-extra/clangd/unittests/TUSchedulerTests.cpp
@@ -700,7 +700,7 @@ TEST_F(TUSchedulerTests, Run) {
}
TEST_F(TUSchedulerTests, TUStatus) {
- class CaptureTUStatus : public DiagnosticsConsumer {
+ class CaptureTUStatus : public ClangdServer::Callbacks {
public:
void onDiagnosticsReady(PathRef File,
std::vector<Diag> Diagnostics) override {}
@@ -721,7 +721,7 @@ TEST_F(TUSchedulerTests, TUStatus) {
} CaptureTUStatus;
MockFSProvider FS;
MockCompilationDatabase CDB;
- ClangdServer Server(CDB, FS, CaptureTUStatus, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &CaptureTUStatus);
Annotations Code("int m^ain () {}");
// We schedule the following tasks in the queue:
diff --git a/clang-tools-extra/clangd/unittests/XRefsTests.cpp b/clang-tools-extra/clangd/unittests/XRefsTests.cpp
index b5c9803cc676..617c5bc05a09 100644
--- a/clang-tools-extra/clangd/unittests/XRefsTests.cpp
+++ b/clang-tools-extra/clangd/unittests/XRefsTests.cpp
@@ -42,11 +42,6 @@ using ::testing::IsEmpty;
using ::testing::Matcher;
using ::testing::UnorderedElementsAreArray;
-class IgnoreDiagnostics : public DiagnosticsConsumer {
- void onDiagnosticsReady(PathRef File,
- std::vector<Diag> Diagnostics) override {}
-};
-
MATCHER_P2(FileRange, File, Range, "") {
return Location{URIForFile::canonicalize(File, testRoot()), Range} == arg;
}
@@ -692,9 +687,8 @@ int [[bar_not_preamble]];
std::string BuildDir = testPath("build");
MockCompilationDatabase CDB(BuildDir, RelPathPrefix);
- IgnoreDiagnostics DiagConsumer;
MockFSProvider FS;
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest());
// Fill the filesystem.
auto FooCpp = testPath("src/foo.cpp");
@@ -729,9 +723,8 @@ int [[bar_not_preamble]];
TEST(GoToInclude, All) {
MockFSProvider FS;
- IgnoreDiagnostics DiagConsumer;
MockCompilationDatabase CDB;
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest());
auto FooCpp = testPath("foo.cpp");
const char *SourceContents = R"cpp(
@@ -804,9 +797,8 @@ TEST(LocateSymbol, WithPreamble) {
// Test stragety: AST should always use the latest preamble instead of last
// good preamble.
MockFSProvider FS;
- IgnoreDiagnostics DiagConsumer;
MockCompilationDatabase CDB;
- ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+ ClangdServer Server(CDB, FS, ClangdServer::optsForTest());
auto FooCpp = testPath("foo.cpp");
// The trigger locations must be the same.
More information about the cfe-commits
mailing list