2017-05-16 17:38:59 +08:00
|
|
|
//===--- ClangdServer.cpp - Main clangd server code --------------*- C++-*-===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===-------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "ClangdServer.h"
|
2017-05-16 22:40:30 +08:00
|
|
|
#include "clang/Format/Format.h"
|
2017-05-16 17:38:59 +08:00
|
|
|
#include "clang/Frontend/CompilerInstance.h"
|
|
|
|
#include "clang/Frontend/CompilerInvocation.h"
|
|
|
|
#include "clang/Tooling/CompilationDatabase.h"
|
2017-05-16 22:40:30 +08:00
|
|
|
#include "llvm/ADT/ArrayRef.h"
|
2017-05-16 17:38:59 +08:00
|
|
|
#include "llvm/Support/FileSystem.h"
|
2017-09-27 23:31:17 +08:00
|
|
|
#include "llvm/Support/Path.h"
|
2017-05-23 21:42:59 +08:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
|
|
|
#include <future>
|
2017-05-16 17:38:59 +08:00
|
|
|
|
2017-05-16 18:06:20 +08:00
|
|
|
using namespace clang;
|
2017-05-16 17:38:59 +08:00
|
|
|
using namespace clang::clangd;
|
|
|
|
|
2017-05-16 22:40:30 +08:00
|
|
|
namespace {
|
|
|
|
|
2017-08-01 23:51:38 +08:00
|
|
|
class FulfillPromiseGuard {
|
|
|
|
public:
|
|
|
|
FulfillPromiseGuard(std::promise<void> &Promise) : Promise(Promise) {}
|
|
|
|
|
|
|
|
~FulfillPromiseGuard() { Promise.set_value(); }
|
|
|
|
|
|
|
|
private:
|
|
|
|
std::promise<void> &Promise;
|
|
|
|
};
|
|
|
|
|
2017-05-16 22:40:30 +08:00
|
|
|
std::vector<tooling::Replacement> formatCode(StringRef Code, StringRef Filename,
|
|
|
|
ArrayRef<tooling::Range> Ranges) {
|
|
|
|
// Call clang-format.
|
|
|
|
// FIXME: Don't ignore style.
|
|
|
|
format::FormatStyle Style = format::getLLVMStyle();
|
|
|
|
auto Result = format::reformat(Style, Code, Ranges, Filename);
|
|
|
|
|
|
|
|
return std::vector<tooling::Replacement>(Result.begin(), Result.end());
|
|
|
|
}
|
|
|
|
|
2017-06-28 18:34:50 +08:00
|
|
|
std::string getStandardResourceDir() {
|
|
|
|
static int Dummy; // Just an address in this process.
|
|
|
|
return CompilerInvocation::GetResourcesPath("clangd", (void *)&Dummy);
|
|
|
|
}
|
|
|
|
|
2017-05-16 22:40:30 +08:00
|
|
|
} // namespace
|
|
|
|
|
|
|
|
size_t clangd::positionToOffset(StringRef Code, Position P) {
|
|
|
|
size_t Offset = 0;
|
|
|
|
for (int I = 0; I != P.line; ++I) {
|
|
|
|
// FIXME: \r\n
|
|
|
|
// FIXME: UTF-8
|
|
|
|
size_t F = Code.find('\n', Offset);
|
|
|
|
if (F == StringRef::npos)
|
|
|
|
return 0; // FIXME: Is this reasonable?
|
|
|
|
Offset = F + 1;
|
|
|
|
}
|
|
|
|
return (Offset == 0 ? 0 : (Offset - 1)) + P.character;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Turn an offset in Code into a [line, column] pair.
|
|
|
|
Position clangd::offsetToPosition(StringRef Code, size_t Offset) {
|
|
|
|
StringRef JustBefore = Code.substr(0, Offset);
|
|
|
|
// FIXME: \r\n
|
|
|
|
// FIXME: UTF-8
|
|
|
|
int Lines = JustBefore.count('\n');
|
|
|
|
int Cols = JustBefore.size() - JustBefore.rfind('\n') - 1;
|
|
|
|
return {Lines, Cols};
|
|
|
|
}
|
|
|
|
|
2017-05-30 23:11:02 +08:00
|
|
|
Tagged<IntrusiveRefCntPtr<vfs::FileSystem>>
|
2017-06-14 17:46:44 +08:00
|
|
|
RealFileSystemProvider::getTaggedFileSystem(PathRef File) {
|
2017-05-30 23:11:02 +08:00
|
|
|
return make_tagged(vfs::getRealFileSystem(), VFSTag());
|
2017-05-26 20:26:51 +08:00
|
|
|
}
|
|
|
|
|
2017-08-14 16:45:47 +08:00
|
|
|
unsigned clangd::getDefaultAsyncThreadsCount() {
|
|
|
|
unsigned HardwareConcurrency = std::thread::hardware_concurrency();
|
|
|
|
// C++ standard says that hardware_concurrency()
|
|
|
|
// may return 0, fallback to 1 worker thread in
|
|
|
|
// that case.
|
|
|
|
if (HardwareConcurrency == 0)
|
|
|
|
return 1;
|
|
|
|
return HardwareConcurrency;
|
|
|
|
}
|
|
|
|
|
|
|
|
ClangdScheduler::ClangdScheduler(unsigned AsyncThreadsCount)
|
|
|
|
: RunSynchronously(AsyncThreadsCount == 0) {
|
2017-05-16 17:38:59 +08:00
|
|
|
if (RunSynchronously) {
|
|
|
|
// Don't start the worker thread if we're running synchronously
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-08-14 16:45:47 +08:00
|
|
|
Workers.reserve(AsyncThreadsCount);
|
|
|
|
for (unsigned I = 0; I < AsyncThreadsCount; ++I) {
|
|
|
|
Workers.push_back(std::thread([this]() {
|
|
|
|
while (true) {
|
2017-10-10 00:26:26 +08:00
|
|
|
UniqueFunction<void()> Request;
|
2017-08-14 16:45:47 +08:00
|
|
|
|
|
|
|
// Pick request from the queue
|
|
|
|
{
|
|
|
|
std::unique_lock<std::mutex> Lock(Mutex);
|
|
|
|
// Wait for more requests.
|
|
|
|
RequestCV.wait(Lock,
|
|
|
|
[this] { return !RequestQueue.empty() || Done; });
|
|
|
|
if (Done)
|
|
|
|
return;
|
|
|
|
|
|
|
|
assert(!RequestQueue.empty() && "RequestQueue was empty");
|
|
|
|
|
|
|
|
// We process requests starting from the front of the queue. Users of
|
|
|
|
// ClangdScheduler have a way to prioritise their requests by putting
|
|
|
|
// them to the either side of the queue (using either addToEnd or
|
|
|
|
// addToFront).
|
|
|
|
Request = std::move(RequestQueue.front());
|
|
|
|
RequestQueue.pop_front();
|
|
|
|
} // unlock Mutex
|
|
|
|
|
2017-10-10 00:26:26 +08:00
|
|
|
Request();
|
2017-08-14 16:45:47 +08:00
|
|
|
}
|
|
|
|
}));
|
|
|
|
}
|
2017-05-16 17:38:59 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
ClangdScheduler::~ClangdScheduler() {
|
|
|
|
if (RunSynchronously)
|
|
|
|
return; // no worker thread is running in that case
|
|
|
|
|
|
|
|
{
|
|
|
|
std::lock_guard<std::mutex> Lock(Mutex);
|
|
|
|
// Wake up the worker thread
|
|
|
|
Done = true;
|
|
|
|
} // unlock Mutex
|
2017-08-14 16:45:47 +08:00
|
|
|
RequestCV.notify_all();
|
|
|
|
|
|
|
|
for (auto &Worker : Workers)
|
|
|
|
Worker.join();
|
2017-05-16 17:38:59 +08:00
|
|
|
}
|
|
|
|
|
2017-06-13 23:59:43 +08:00
|
|
|
ClangdServer::ClangdServer(GlobalCompilationDatabase &CDB,
|
|
|
|
DiagnosticsConsumer &DiagConsumer,
|
|
|
|
FileSystemProvider &FSProvider,
|
2017-10-23 22:46:48 +08:00
|
|
|
unsigned AsyncThreadsCount,
|
|
|
|
clangd::CodeCompleteOptions CodeCompleteOpts,
|
2017-09-20 15:24:15 +08:00
|
|
|
clangd::Logger &Logger,
|
2017-06-28 18:34:50 +08:00
|
|
|
llvm::Optional<StringRef> ResourceDir)
|
2017-09-20 15:24:15 +08:00
|
|
|
: Logger(Logger), CDB(CDB), DiagConsumer(DiagConsumer),
|
|
|
|
FSProvider(FSProvider),
|
2017-06-28 18:34:50 +08:00
|
|
|
ResourceDir(ResourceDir ? ResourceDir->str() : getStandardResourceDir()),
|
2017-05-16 17:38:59 +08:00
|
|
|
PCHs(std::make_shared<PCHContainerOperations>()),
|
2017-10-23 22:46:48 +08:00
|
|
|
CodeCompleteOpts(CodeCompleteOpts), WorkScheduler(AsyncThreadsCount) {}
|
2017-05-16 17:38:59 +08:00
|
|
|
|
2017-09-27 23:31:17 +08:00
|
|
|
void ClangdServer::setRootPath(PathRef RootPath) {
|
|
|
|
std::string NewRootPath = llvm::sys::path::convert_to_slash(
|
|
|
|
RootPath, llvm::sys::path::Style::posix);
|
|
|
|
if (llvm::sys::fs::is_directory(NewRootPath))
|
|
|
|
this->RootPath = NewRootPath;
|
|
|
|
}
|
|
|
|
|
2017-08-01 23:51:38 +08:00
|
|
|
std::future<void> ClangdServer::addDocument(PathRef File, StringRef Contents) {
|
2017-05-23 21:42:59 +08:00
|
|
|
DocVersion Version = DraftMgr.updateDraft(File, Contents);
|
|
|
|
|
2017-08-01 23:51:38 +08:00
|
|
|
auto TaggedFS = FSProvider.getTaggedFileSystem(File);
|
2017-09-27 23:31:17 +08:00
|
|
|
std::shared_ptr<CppFile> Resources = Units.getOrCreateFile(
|
|
|
|
File, ResourceDir, CDB, PCHs, TaggedFS.Value, Logger);
|
2017-08-14 16:17:24 +08:00
|
|
|
return scheduleReparseAndDiags(File, VersionedDraft{Version, Contents.str()},
|
|
|
|
std::move(Resources), std::move(TaggedFS));
|
2017-05-16 17:38:59 +08:00
|
|
|
}
|
|
|
|
|
2017-08-01 23:51:38 +08:00
|
|
|
std::future<void> ClangdServer::removeDocument(PathRef File) {
|
2017-08-14 16:17:24 +08:00
|
|
|
DraftMgr.removeDraft(File);
|
|
|
|
std::shared_ptr<CppFile> Resources = Units.removeIfPresent(File);
|
|
|
|
return scheduleCancelRebuild(std::move(Resources));
|
2017-05-16 17:38:59 +08:00
|
|
|
}
|
|
|
|
|
2017-08-01 23:51:38 +08:00
|
|
|
std::future<void> ClangdServer::forceReparse(PathRef File) {
|
2017-08-14 16:37:32 +08:00
|
|
|
auto FileContents = DraftMgr.getDraft(File);
|
|
|
|
assert(FileContents.Draft &&
|
|
|
|
"forceReparse() was called for non-added document");
|
|
|
|
|
|
|
|
auto TaggedFS = FSProvider.getTaggedFileSystem(File);
|
|
|
|
auto Recreated = Units.recreateFileIfCompileCommandChanged(
|
2017-09-20 15:24:15 +08:00
|
|
|
File, ResourceDir, CDB, PCHs, TaggedFS.Value, Logger);
|
2017-08-14 16:37:32 +08:00
|
|
|
|
|
|
|
// Note that std::future from this cleanup action is ignored.
|
|
|
|
scheduleCancelRebuild(std::move(Recreated.RemovedFile));
|
|
|
|
// Schedule a reparse.
|
|
|
|
return scheduleReparseAndDiags(File, std::move(FileContents),
|
|
|
|
std::move(Recreated.FileInCollection),
|
|
|
|
std::move(TaggedFS));
|
2017-05-26 20:26:51 +08:00
|
|
|
}
|
|
|
|
|
2017-10-06 01:04:13 +08:00
|
|
|
std::future<Tagged<std::vector<CompletionItem>>>
|
2017-06-13 22:15:56 +08:00
|
|
|
ClangdServer::codeComplete(PathRef File, Position Pos,
|
2017-08-01 01:09:29 +08:00
|
|
|
llvm::Optional<StringRef> OverridenContents,
|
|
|
|
IntrusiveRefCntPtr<vfs::FileSystem> *UsedFS) {
|
2017-10-06 01:04:13 +08:00
|
|
|
std::string Contents;
|
|
|
|
if (OverridenContents) {
|
|
|
|
Contents = *OverridenContents;
|
|
|
|
} else {
|
2017-06-13 22:15:56 +08:00
|
|
|
auto FileContents = DraftMgr.getDraft(File);
|
|
|
|
assert(FileContents.Draft &&
|
|
|
|
"codeComplete is called for non-added document");
|
|
|
|
|
2017-10-06 01:04:13 +08:00
|
|
|
Contents = std::move(*FileContents.Draft);
|
2017-06-13 22:15:56 +08:00
|
|
|
}
|
2017-05-16 17:38:59 +08:00
|
|
|
|
2017-06-14 17:46:44 +08:00
|
|
|
auto TaggedFS = FSProvider.getTaggedFileSystem(File);
|
2017-08-01 01:09:29 +08:00
|
|
|
if (UsedFS)
|
|
|
|
*UsedFS = TaggedFS.Value;
|
|
|
|
|
2017-08-01 23:51:38 +08:00
|
|
|
std::shared_ptr<CppFile> Resources = Units.getFile(File);
|
|
|
|
assert(Resources && "Calling completion on non-added file");
|
|
|
|
|
2017-10-06 01:04:13 +08:00
|
|
|
using PackagedTask =
|
|
|
|
std::packaged_task<Tagged<std::vector<CompletionItem>>()>;
|
|
|
|
|
|
|
|
// Remember the current Preamble and use it when async task starts executing.
|
|
|
|
// At the point when async task starts executing, we may have a different
|
|
|
|
// Preamble in Resources. However, we assume the Preamble that we obtain here
|
|
|
|
// is reusable in completion more often.
|
|
|
|
std::shared_ptr<const PreambleData> Preamble =
|
|
|
|
Resources->getPossiblyStalePreamble();
|
|
|
|
// A task that will be run asynchronously.
|
|
|
|
PackagedTask Task([=]() mutable { // 'mutable' to reassign Preamble variable.
|
|
|
|
if (!Preamble) {
|
|
|
|
// Maybe we built some preamble before processing this request.
|
|
|
|
Preamble = Resources->getPossiblyStalePreamble();
|
|
|
|
}
|
|
|
|
// FIXME(ibiryukov): even if Preamble is non-null, we may want to check
|
|
|
|
// both the old and the new version in case only one of them matches.
|
|
|
|
|
|
|
|
std::vector<CompletionItem> Result = clangd::codeComplete(
|
|
|
|
File, Resources->getCompileCommand(),
|
|
|
|
Preamble ? &Preamble->Preamble : nullptr, Contents, Pos, TaggedFS.Value,
|
2017-10-23 22:46:48 +08:00
|
|
|
PCHs, CodeCompleteOpts, Logger);
|
2017-10-06 01:04:13 +08:00
|
|
|
return make_tagged(std::move(Result), std::move(TaggedFS.Tag));
|
|
|
|
});
|
|
|
|
|
|
|
|
auto Future = Task.get_future();
|
|
|
|
// FIXME(ibiryukov): to reduce overhead for wrapping the same callable
|
|
|
|
// multiple times, ClangdScheduler should return future<> itself.
|
|
|
|
WorkScheduler.addToFront([](PackagedTask Task) { Task(); }, std::move(Task));
|
|
|
|
return Future;
|
2017-05-16 17:38:59 +08:00
|
|
|
}
|
2017-05-23 21:42:59 +08:00
|
|
|
|
2017-10-06 19:54:17 +08:00
|
|
|
Tagged<SignatureHelp>
|
|
|
|
ClangdServer::signatureHelp(PathRef File, Position Pos,
|
|
|
|
llvm::Optional<StringRef> OverridenContents,
|
|
|
|
IntrusiveRefCntPtr<vfs::FileSystem> *UsedFS) {
|
|
|
|
std::string DraftStorage;
|
|
|
|
if (!OverridenContents) {
|
|
|
|
auto FileContents = DraftMgr.getDraft(File);
|
|
|
|
assert(FileContents.Draft &&
|
|
|
|
"signatureHelp is called for non-added document");
|
|
|
|
|
|
|
|
DraftStorage = std::move(*FileContents.Draft);
|
|
|
|
OverridenContents = DraftStorage;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto TaggedFS = FSProvider.getTaggedFileSystem(File);
|
|
|
|
if (UsedFS)
|
|
|
|
*UsedFS = TaggedFS.Value;
|
|
|
|
|
|
|
|
std::shared_ptr<CppFile> Resources = Units.getFile(File);
|
|
|
|
assert(Resources && "Calling signatureHelp on non-added file");
|
|
|
|
|
|
|
|
auto Preamble = Resources->getPossiblyStalePreamble();
|
|
|
|
auto Result = clangd::signatureHelp(File, Resources->getCompileCommand(),
|
|
|
|
Preamble ? &Preamble->Preamble : nullptr,
|
|
|
|
*OverridenContents, Pos, TaggedFS.Value,
|
|
|
|
PCHs, Logger);
|
|
|
|
return make_tagged(std::move(Result), TaggedFS.Tag);
|
|
|
|
}
|
|
|
|
|
2017-05-16 22:40:30 +08:00
|
|
|
std::vector<tooling::Replacement> ClangdServer::formatRange(PathRef File,
|
|
|
|
Range Rng) {
|
|
|
|
std::string Code = getDocument(File);
|
|
|
|
|
|
|
|
size_t Begin = positionToOffset(Code, Rng.start);
|
|
|
|
size_t Len = positionToOffset(Code, Rng.end) - Begin;
|
|
|
|
return formatCode(Code, File, {tooling::Range(Begin, Len)});
|
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<tooling::Replacement> ClangdServer::formatFile(PathRef File) {
|
|
|
|
// Format everything.
|
|
|
|
std::string Code = getDocument(File);
|
|
|
|
return formatCode(Code, File, {tooling::Range(0, Code.size())});
|
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<tooling::Replacement> ClangdServer::formatOnType(PathRef File,
|
|
|
|
Position Pos) {
|
|
|
|
// Look for the previous opening brace from the character position and
|
|
|
|
// format starting from there.
|
|
|
|
std::string Code = getDocument(File);
|
|
|
|
size_t CursorPos = positionToOffset(Code, Pos);
|
|
|
|
size_t PreviousLBracePos = StringRef(Code).find_last_of('{', CursorPos);
|
|
|
|
if (PreviousLBracePos == StringRef::npos)
|
|
|
|
PreviousLBracePos = CursorPos;
|
|
|
|
size_t Len = 1 + CursorPos - PreviousLBracePos;
|
|
|
|
|
|
|
|
return formatCode(Code, File, {tooling::Range(PreviousLBracePos, Len)});
|
|
|
|
}
|
2017-05-16 17:38:59 +08:00
|
|
|
|
|
|
|
std::string ClangdServer::getDocument(PathRef File) {
|
|
|
|
auto draft = DraftMgr.getDraft(File);
|
|
|
|
assert(draft.Draft && "File is not tracked, cannot get contents");
|
|
|
|
return *draft.Draft;
|
|
|
|
}
|
|
|
|
|
2017-05-23 21:42:59 +08:00
|
|
|
std::string ClangdServer::dumpAST(PathRef File) {
|
2017-08-01 23:51:38 +08:00
|
|
|
std::shared_ptr<CppFile> Resources = Units.getFile(File);
|
|
|
|
assert(Resources && "dumpAST is called for non-added document");
|
|
|
|
|
|
|
|
std::string Result;
|
2017-08-02 02:27:58 +08:00
|
|
|
Resources->getAST().get()->runUnderLock([&Result](ParsedAST *AST) {
|
2017-08-01 23:51:38 +08:00
|
|
|
llvm::raw_string_ostream ResultOS(Result);
|
|
|
|
if (AST) {
|
|
|
|
clangd::dumpAST(*AST, ResultOS);
|
|
|
|
} else {
|
|
|
|
ResultOS << "<no-ast>";
|
|
|
|
}
|
|
|
|
ResultOS.flush();
|
2017-05-23 21:42:59 +08:00
|
|
|
});
|
2017-08-01 23:51:38 +08:00
|
|
|
return Result;
|
2017-05-16 17:38:59 +08:00
|
|
|
}
|
2017-06-29 00:12:10 +08:00
|
|
|
|
2017-08-01 23:51:38 +08:00
|
|
|
Tagged<std::vector<Location>> ClangdServer::findDefinitions(PathRef File,
|
|
|
|
Position Pos) {
|
2017-06-29 00:12:10 +08:00
|
|
|
auto FileContents = DraftMgr.getDraft(File);
|
2017-08-01 23:51:38 +08:00
|
|
|
assert(FileContents.Draft &&
|
|
|
|
"findDefinitions is called for non-added document");
|
2017-06-29 00:12:10 +08:00
|
|
|
|
|
|
|
auto TaggedFS = FSProvider.getTaggedFileSystem(File);
|
2017-08-01 23:51:38 +08:00
|
|
|
|
|
|
|
std::shared_ptr<CppFile> Resources = Units.getFile(File);
|
|
|
|
assert(Resources && "Calling findDefinitions on non-added file");
|
|
|
|
|
|
|
|
std::vector<Location> Result;
|
2017-09-20 15:24:15 +08:00
|
|
|
Resources->getAST().get()->runUnderLock([Pos, &Result, this](ParsedAST *AST) {
|
2017-08-01 23:51:38 +08:00
|
|
|
if (!AST)
|
|
|
|
return;
|
2017-09-20 15:24:15 +08:00
|
|
|
Result = clangd::findDefinitions(*AST, Pos, Logger);
|
2017-08-01 23:51:38 +08:00
|
|
|
});
|
2017-06-29 00:12:10 +08:00
|
|
|
return make_tagged(std::move(Result), TaggedFS.Tag);
|
|
|
|
}
|
2017-08-14 16:17:24 +08:00
|
|
|
|
2017-09-28 11:14:40 +08:00
|
|
|
llvm::Optional<Path> ClangdServer::switchSourceHeader(PathRef Path) {
|
|
|
|
|
|
|
|
StringRef SourceExtensions[] = {".cpp", ".c", ".cc", ".cxx",
|
|
|
|
".c++", ".m", ".mm"};
|
|
|
|
StringRef HeaderExtensions[] = {".h", ".hh", ".hpp", ".hxx", ".inc"};
|
|
|
|
|
|
|
|
StringRef PathExt = llvm::sys::path::extension(Path);
|
|
|
|
|
|
|
|
// Lookup in a list of known extensions.
|
|
|
|
auto SourceIter =
|
|
|
|
std::find_if(std::begin(SourceExtensions), std::end(SourceExtensions),
|
|
|
|
[&PathExt](PathRef SourceExt) {
|
|
|
|
return SourceExt.equals_lower(PathExt);
|
|
|
|
});
|
|
|
|
bool IsSource = SourceIter != std::end(SourceExtensions);
|
|
|
|
|
|
|
|
auto HeaderIter =
|
|
|
|
std::find_if(std::begin(HeaderExtensions), std::end(HeaderExtensions),
|
|
|
|
[&PathExt](PathRef HeaderExt) {
|
|
|
|
return HeaderExt.equals_lower(PathExt);
|
|
|
|
});
|
|
|
|
|
|
|
|
bool IsHeader = HeaderIter != std::end(HeaderExtensions);
|
|
|
|
|
|
|
|
// We can only switch between extensions known extensions.
|
|
|
|
if (!IsSource && !IsHeader)
|
|
|
|
return llvm::None;
|
|
|
|
|
|
|
|
// Array to lookup extensions for the switch. An opposite of where original
|
|
|
|
// extension was found.
|
|
|
|
ArrayRef<StringRef> NewExts;
|
|
|
|
if (IsSource)
|
|
|
|
NewExts = HeaderExtensions;
|
|
|
|
else
|
|
|
|
NewExts = SourceExtensions;
|
|
|
|
|
|
|
|
// Storage for the new path.
|
|
|
|
SmallString<128> NewPath = StringRef(Path);
|
|
|
|
|
|
|
|
// Instance of vfs::FileSystem, used for file existence checks.
|
|
|
|
auto FS = FSProvider.getTaggedFileSystem(Path).Value;
|
|
|
|
|
|
|
|
// Loop through switched extension candidates.
|
|
|
|
for (StringRef NewExt : NewExts) {
|
|
|
|
llvm::sys::path::replace_extension(NewPath, NewExt);
|
|
|
|
if (FS->exists(NewPath))
|
|
|
|
return NewPath.str().str(); // First str() to convert from SmallString to
|
|
|
|
// StringRef, second to convert from StringRef
|
|
|
|
// to std::string
|
2017-10-06 22:39:39 +08:00
|
|
|
|
2017-09-28 11:14:40 +08:00
|
|
|
// Also check NewExt in upper-case, just in case.
|
|
|
|
llvm::sys::path::replace_extension(NewPath, NewExt.upper());
|
|
|
|
if (FS->exists(NewPath))
|
|
|
|
return NewPath.str().str();
|
|
|
|
}
|
|
|
|
|
|
|
|
return llvm::None;
|
|
|
|
}
|
|
|
|
|
2017-08-14 16:17:24 +08:00
|
|
|
std::future<void> ClangdServer::scheduleReparseAndDiags(
|
|
|
|
PathRef File, VersionedDraft Contents, std::shared_ptr<CppFile> Resources,
|
|
|
|
Tagged<IntrusiveRefCntPtr<vfs::FileSystem>> TaggedFS) {
|
|
|
|
|
|
|
|
assert(Contents.Draft && "Draft must have contents");
|
2017-10-11 00:12:54 +08:00
|
|
|
UniqueFunction<llvm::Optional<std::vector<DiagWithFixIts>>()>
|
|
|
|
DeferredRebuild =
|
|
|
|
Resources->deferRebuild(*Contents.Draft, TaggedFS.Value);
|
2017-08-14 16:17:24 +08:00
|
|
|
std::promise<void> DonePromise;
|
|
|
|
std::future<void> DoneFuture = DonePromise.get_future();
|
|
|
|
|
|
|
|
DocVersion Version = Contents.Version;
|
|
|
|
Path FileStr = File;
|
|
|
|
VFSTag Tag = TaggedFS.Tag;
|
|
|
|
auto ReparseAndPublishDiags =
|
|
|
|
[this, FileStr, Version,
|
2017-10-11 00:12:54 +08:00
|
|
|
Tag](UniqueFunction<llvm::Optional<std::vector<DiagWithFixIts>>()>
|
2017-08-14 16:17:24 +08:00
|
|
|
DeferredRebuild,
|
|
|
|
std::promise<void> DonePromise) -> void {
|
|
|
|
FulfillPromiseGuard Guard(DonePromise);
|
|
|
|
|
|
|
|
auto CurrentVersion = DraftMgr.getVersion(FileStr);
|
|
|
|
if (CurrentVersion != Version)
|
|
|
|
return; // This request is outdated
|
|
|
|
|
2017-10-11 00:12:54 +08:00
|
|
|
auto Diags = DeferredRebuild();
|
2017-08-14 16:17:24 +08:00
|
|
|
if (!Diags)
|
|
|
|
return; // A new reparse was requested before this one completed.
|
2017-09-20 20:58:55 +08:00
|
|
|
|
|
|
|
// We need to serialize access to resulting diagnostics to avoid calling
|
|
|
|
// `onDiagnosticsReady` in the wrong order.
|
|
|
|
std::lock_guard<std::mutex> DiagsLock(DiagnosticsMutex);
|
|
|
|
DocVersion &LastReportedDiagsVersion = ReportedDiagnosticVersions[FileStr];
|
|
|
|
// FIXME(ibiryukov): get rid of '<' comparison here. In the current
|
|
|
|
// implementation diagnostics will not be reported after version counters'
|
|
|
|
// overflow. This should not happen in practice, since DocVersion is a
|
|
|
|
// 64-bit unsigned integer.
|
|
|
|
if (Version < LastReportedDiagsVersion)
|
|
|
|
return;
|
|
|
|
LastReportedDiagsVersion = Version;
|
|
|
|
|
2017-08-14 16:17:24 +08:00
|
|
|
DiagConsumer.onDiagnosticsReady(FileStr,
|
|
|
|
make_tagged(std::move(*Diags), Tag));
|
|
|
|
};
|
|
|
|
|
|
|
|
WorkScheduler.addToFront(std::move(ReparseAndPublishDiags),
|
|
|
|
std::move(DeferredRebuild), std::move(DonePromise));
|
|
|
|
return DoneFuture;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::future<void>
|
|
|
|
ClangdServer::scheduleCancelRebuild(std::shared_ptr<CppFile> Resources) {
|
|
|
|
std::promise<void> DonePromise;
|
|
|
|
std::future<void> DoneFuture = DonePromise.get_future();
|
|
|
|
if (!Resources) {
|
|
|
|
// No need to schedule any cleanup.
|
|
|
|
DonePromise.set_value();
|
|
|
|
return DoneFuture;
|
|
|
|
}
|
|
|
|
|
2017-10-11 00:12:54 +08:00
|
|
|
UniqueFunction<void()> DeferredCancel = Resources->deferCancelRebuild();
|
2017-08-14 16:17:24 +08:00
|
|
|
auto CancelReparses = [Resources](std::promise<void> DonePromise,
|
2017-10-11 00:12:54 +08:00
|
|
|
UniqueFunction<void()> DeferredCancel) {
|
2017-08-14 16:17:24 +08:00
|
|
|
FulfillPromiseGuard Guard(DonePromise);
|
2017-10-11 00:12:54 +08:00
|
|
|
DeferredCancel();
|
2017-08-14 16:17:24 +08:00
|
|
|
};
|
|
|
|
WorkScheduler.addToFront(std::move(CancelReparses), std::move(DonePromise),
|
|
|
|
std::move(DeferredCancel));
|
|
|
|
return DoneFuture;
|
|
|
|
}
|
2017-10-03 02:00:37 +08:00
|
|
|
|
|
|
|
void ClangdServer::onFileEvent(const DidChangeWatchedFilesParams &Params) {
|
|
|
|
// FIXME: Do nothing for now. This will be used for indexing and potentially
|
|
|
|
// invalidating other caches.
|
|
|
|
}
|