clang-tools-extra/clangd/ClangdServer.cpp - toolchain/llvm-project - Gitiles

 //===--- 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"
 #include "clang/Format/Format.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Tooling/CompilationDatabase.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/raw_ostream.h"
 #include <future>

 using namespace clang;
 using namespace clang::clangd;

 namespace {

 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());
 }

 std::string getStandardResourceDir() {
   static int Dummy; // Just an address in this process.
   return CompilerInvocation::GetResourcesPath("clangd", (void *)&Dummy);
 }

 } // 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};
 }

 Tagged<IntrusiveRefCntPtr<vfs::FileSystem>>
 RealFileSystemProvider::getTaggedFileSystem(PathRef File) {
   return make_tagged(vfs::getRealFileSystem(), VFSTag());
 }

 ClangdScheduler::ClangdScheduler(bool RunSynchronously)
     : RunSynchronously(RunSynchronously) {
   if (RunSynchronously) {
     // Don't start the worker thread if we're running synchronously
     return;
   }

   // Initialize Worker in ctor body, rather than init list to avoid potentially
   // using not-yet-initialized members
   Worker = std::thread([this]() {
     while (true) {
       std::function<void()> Request;

       // 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

       Request();
     }
   });
 }

 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
   RequestCV.notify_one();
   Worker.join();
 }

 void ClangdScheduler::addToFront(std::function<void()> Request) {
   if (RunSynchronously) {
     Request();
     return;
   }

   {
     std::lock_guard<std::mutex> Lock(Mutex);
     RequestQueue.push_front(Request);
   }
   RequestCV.notify_one();
 }

 void ClangdScheduler::addToEnd(std::function<void()> Request) {
   if (RunSynchronously) {
     Request();
     return;
   }

   {
     std::lock_guard<std::mutex> Lock(Mutex);
     RequestQueue.push_back(Request);
   }
   RequestCV.notify_one();
 }

 ClangdServer::ClangdServer(GlobalCompilationDatabase &CDB,
                            DiagnosticsConsumer &DiagConsumer,
                            FileSystemProvider &FSProvider,
                            bool RunSynchronously,
                            llvm::Optional<StringRef> ResourceDir)
     : CDB(CDB), DiagConsumer(DiagConsumer), FSProvider(FSProvider),
       ResourceDir(ResourceDir ? ResourceDir->str() : getStandardResourceDir()),
       PCHs(std::make_shared<PCHContainerOperations>()),
       WorkScheduler(RunSynchronously) {}

 void ClangdServer::addDocument(PathRef File, StringRef Contents) {
   DocVersion Version = DraftMgr.updateDraft(File, Contents);
   Path FileStr = File;
   WorkScheduler.addToFront([this, FileStr, Version]() {
     auto FileContents = DraftMgr.getDraft(FileStr);
     if (FileContents.Version != Version)
       return; // This request is outdated, do nothing

     assert(FileContents.Draft &&
            "No contents inside a file that was scheduled for reparse");
     auto TaggedFS = FSProvider.getTaggedFileSystem(FileStr);
     Units.runOnUnit(
         FileStr, *FileContents.Draft, ResourceDir, CDB, PCHs, TaggedFS.Value,
         [&](ClangdUnit const &Unit) {
           DiagConsumer.onDiagnosticsReady(
               FileStr, make_tagged(Unit.getLocalDiagnostics(), TaggedFS.Tag));
         });
   });
 }

 void ClangdServer::removeDocument(PathRef File) {
   auto Version = DraftMgr.removeDraft(File);
   Path FileStr = File;
   WorkScheduler.addToFront([this, FileStr, Version]() {
     if (Version != DraftMgr.getVersion(FileStr))
       return; // This request is outdated, do nothing

     Units.removeUnitIfPresent(FileStr);
   });
 }

 void ClangdServer::forceReparse(PathRef File) {
   // The addDocument schedules the reparse even if the contents of the file
   // never changed, so we just call it here.
   addDocument(File, getDocument(File));
 }

 Tagged<std::vector<CompletionItem>>
 ClangdServer::codeComplete(PathRef File, Position Pos,
                            llvm::Optional<StringRef> OverridenContents) {
   std::string DraftStorage;
   if (!OverridenContents) {
     auto FileContents = DraftMgr.getDraft(File);
     assert(FileContents.Draft &&
            "codeComplete is called for non-added document");

     DraftStorage = std::move(*FileContents.Draft);
     OverridenContents = DraftStorage;
   }

   std::vector<CompletionItem> Result;
   auto TaggedFS = FSProvider.getTaggedFileSystem(File);
   // It would be nice to use runOnUnitWithoutReparse here, but we can't
   // guarantee the correctness of code completion cache here if we don't do the
   // reparse.
   Units.runOnUnit(File, *OverridenContents, ResourceDir, CDB, PCHs,
                   TaggedFS.Value, [&](ClangdUnit &Unit) {
                     Result = Unit.codeComplete(*OverridenContents, Pos,
                                                TaggedFS.Value);
                   });
   return make_tagged(std::move(Result), TaggedFS.Tag);
 }

 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)});
 }

 std::string ClangdServer::getDocument(PathRef File) {
   auto draft = DraftMgr.getDraft(File);
   assert(draft.Draft && "File is not tracked, cannot get contents");
   return *draft.Draft;
 }

 std::string ClangdServer::dumpAST(PathRef File) {
   std::promise<std::string> DumpPromise;
   auto DumpFuture = DumpPromise.get_future();
   auto Version = DraftMgr.getVersion(File);

   WorkScheduler.addToEnd([this, &DumpPromise, File, Version]() {
     assert(DraftMgr.getVersion(File) == Version && "Version has changed");

     Units.runOnExistingUnit(File, [&DumpPromise](ClangdUnit &Unit) {
       std::string Result;

       llvm::raw_string_ostream ResultOS(Result);
       Unit.dumpAST(ResultOS);
       ResultOS.flush();

       DumpPromise.set_value(std::move(Result));
     });
   });
   return DumpFuture.get();
 }

 Tagged<std::vector<Location>>
 ClangdServer::findDefinitions(PathRef File, Position Pos) {
   auto FileContents = DraftMgr.getDraft(File);
   assert(FileContents.Draft && "findDefinitions is called for non-added document");

   std::vector<Location> Result;
   auto TaggedFS = FSProvider.getTaggedFileSystem(File);
   Units.runOnUnit(File, *FileContents.Draft, ResourceDir, CDB, PCHs,
       TaggedFS.Value, [&](ClangdUnit &Unit) {
         Result = Unit.findDefinitions(Pos);
       });
   return make_tagged(std::move(Result), TaggedFS.Tag);
 }
	//===--- 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"
	#include "clang/Format/Format.h"
	#include "clang/Frontend/ASTUnit.h"
	#include "clang/Frontend/CompilerInstance.h"
	#include "clang/Frontend/CompilerInvocation.h"
	#include "clang/Tooling/CompilationDatabase.h"
	#include "llvm/ADT/ArrayRef.h"
	#include "llvm/Support/FileSystem.h"
	#include "llvm/Support/raw_ostream.h"
	#include <future>

	using namespace clang;
	using namespace clang::clangd;

	namespace {

	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());
	}

	std::string getStandardResourceDir() {
	static int Dummy; // Just an address in this process.
	return CompilerInvocation::GetResourcesPath("clangd", (void *)&Dummy);
	}

	} // 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};
	}

	Tagged<IntrusiveRefCntPtr<vfs::FileSystem>>
	RealFileSystemProvider::getTaggedFileSystem(PathRef File) {
	return make_tagged(vfs::getRealFileSystem(), VFSTag());
	}

	ClangdScheduler::ClangdScheduler(bool RunSynchronously)
	: RunSynchronously(RunSynchronously) {
	if (RunSynchronously) {
	// Don't start the worker thread if we're running synchronously
	return;
	}

	// Initialize Worker in ctor body, rather than init list to avoid potentially
	// using not-yet-initialized members
	Worker = std::thread([this]() {
	while (true) {
	std::function<void()> Request;

	// 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

	Request();
	}
	});
	}

	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
	RequestCV.notify_one();
	Worker.join();
	}

	void ClangdScheduler::addToFront(std::function<void()> Request) {
	if (RunSynchronously) {
	Request();
	return;
	}

	{
	std::lock_guard<std::mutex> Lock(Mutex);
	RequestQueue.push_front(Request);
	}
	RequestCV.notify_one();
	}

	void ClangdScheduler::addToEnd(std::function<void()> Request) {
	if (RunSynchronously) {
	Request();
	return;
	}

	{
	std::lock_guard<std::mutex> Lock(Mutex);
	RequestQueue.push_back(Request);
	}
	RequestCV.notify_one();
	}

	ClangdServer::ClangdServer(GlobalCompilationDatabase &CDB,
	DiagnosticsConsumer &DiagConsumer,
	FileSystemProvider &FSProvider,
	bool RunSynchronously,
	llvm::Optional<StringRef> ResourceDir)
	: CDB(CDB), DiagConsumer(DiagConsumer), FSProvider(FSProvider),
	ResourceDir(ResourceDir ? ResourceDir->str() : getStandardResourceDir()),
	PCHs(std::make_shared<PCHContainerOperations>()),
	WorkScheduler(RunSynchronously) {}

	void ClangdServer::addDocument(PathRef File, StringRef Contents) {
	DocVersion Version = DraftMgr.updateDraft(File, Contents);
	Path FileStr = File;
	WorkScheduler.addToFront([this, FileStr, Version]() {
	auto FileContents = DraftMgr.getDraft(FileStr);
	if (FileContents.Version != Version)
	return; // This request is outdated, do nothing

	assert(FileContents.Draft &&
	"No contents inside a file that was scheduled for reparse");
	auto TaggedFS = FSProvider.getTaggedFileSystem(FileStr);
	Units.runOnUnit(
	FileStr, *FileContents.Draft, ResourceDir, CDB, PCHs, TaggedFS.Value,
	[&](ClangdUnit const &Unit) {
	DiagConsumer.onDiagnosticsReady(
	FileStr, make_tagged(Unit.getLocalDiagnostics(), TaggedFS.Tag));
	});
	});
	}

	void ClangdServer::removeDocument(PathRef File) {
	auto Version = DraftMgr.removeDraft(File);
	Path FileStr = File;
	WorkScheduler.addToFront([this, FileStr, Version]() {
	if (Version != DraftMgr.getVersion(FileStr))
	return; // This request is outdated, do nothing

	Units.removeUnitIfPresent(FileStr);
	});
	}

	void ClangdServer::forceReparse(PathRef File) {
	// The addDocument schedules the reparse even if the contents of the file
	// never changed, so we just call it here.
	addDocument(File, getDocument(File));
	}

	Tagged<std::vector<CompletionItem>>
	ClangdServer::codeComplete(PathRef File, Position Pos,
	llvm::Optional<StringRef> OverridenContents) {
	std::string DraftStorage;
	if (!OverridenContents) {
	auto FileContents = DraftMgr.getDraft(File);
	assert(FileContents.Draft &&
	"codeComplete is called for non-added document");

	DraftStorage = std::move(*FileContents.Draft);
	OverridenContents = DraftStorage;
	}

	std::vector<CompletionItem> Result;
	auto TaggedFS = FSProvider.getTaggedFileSystem(File);
	// It would be nice to use runOnUnitWithoutReparse here, but we can't
	// guarantee the correctness of code completion cache here if we don't do the
	// reparse.
	Units.runOnUnit(File, *OverridenContents, ResourceDir, CDB, PCHs,
	TaggedFS.Value, [&](ClangdUnit &Unit) {
	Result = Unit.codeComplete(*OverridenContents, Pos,
	TaggedFS.Value);
	});
	return make_tagged(std::move(Result), TaggedFS.Tag);
	}

	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)});
	}

	std::string ClangdServer::getDocument(PathRef File) {
	auto draft = DraftMgr.getDraft(File);
	assert(draft.Draft && "File is not tracked, cannot get contents");
	return *draft.Draft;
	}

	std::string ClangdServer::dumpAST(PathRef File) {
	std::promise<std::string> DumpPromise;
	auto DumpFuture = DumpPromise.get_future();
	auto Version = DraftMgr.getVersion(File);

	WorkScheduler.addToEnd([this, &DumpPromise, File, Version]() {
	assert(DraftMgr.getVersion(File) == Version && "Version has changed");

	Units.runOnExistingUnit(File, [&DumpPromise](ClangdUnit &Unit) {
	std::string Result;

	llvm::raw_string_ostream ResultOS(Result);
	Unit.dumpAST(ResultOS);
	ResultOS.flush();

	DumpPromise.set_value(std::move(Result));
	});
	});
	return DumpFuture.get();
	}

	Tagged<std::vector<Location>>
	ClangdServer::findDefinitions(PathRef File, Position Pos) {
	auto FileContents = DraftMgr.getDraft(File);
	assert(FileContents.Draft && "findDefinitions is called for non-added document");

	std::vector<Location> Result;
	auto TaggedFS = FSProvider.getTaggedFileSystem(File);
	Units.runOnUnit(File, *FileContents.Draft, ResourceDir, CDB, PCHs,
	TaggedFS.Value, [&](ClangdUnit &Unit) {
	Result = Unit.findDefinitions(Pos);
	});
	return make_tagged(std::move(Result), TaggedFS.Tag);
	}