blob: db65d5c351fefbbcd2740cb50eb2fc60149fc744 [file] [log] [blame]
Ilya Biryukov38d79772017-05-16 09:38:59 +00001//===--- ClangdServer.cpp - Main clangd server code --------------*- C++-*-===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===-------------------------------------------------------------------===//
9
10#include "ClangdServer.h"
Sam McCalla66d2cb2017-12-19 17:06:07 +000011#include "CodeComplete.h"
Eric Liuc5105f92018-02-16 14:15:55 +000012#include "Headers.h"
Sam McCallb536a2a2017-12-19 12:23:48 +000013#include "SourceCode.h"
Sam McCalla66d2cb2017-12-19 17:06:07 +000014#include "XRefs.h"
Sam McCall0faecf02018-01-15 12:33:00 +000015#include "index/Merge.h"
Ilya Biryukovafb55542017-05-16 14:40:30 +000016#include "clang/Format/Format.h"
Ilya Biryukov38d79772017-05-16 09:38:59 +000017#include "clang/Frontend/CompilerInstance.h"
18#include "clang/Frontend/CompilerInvocation.h"
19#include "clang/Tooling/CompilationDatabase.h"
Ilya Biryukov9e11c4c2017-11-15 18:04:56 +000020#include "clang/Tooling/Refactoring/RefactoringResultConsumer.h"
21#include "clang/Tooling/Refactoring/Rename/RenamingAction.h"
Ilya Biryukovafb55542017-05-16 14:40:30 +000022#include "llvm/ADT/ArrayRef.h"
Sam McCallb5f5eb62018-01-25 17:01:39 +000023#include "llvm/ADT/ScopeExit.h"
Benjamin Krameree19f162017-10-26 12:28:13 +000024#include "llvm/Support/Errc.h"
Ilya Biryukov38d79772017-05-16 09:38:59 +000025#include "llvm/Support/FileSystem.h"
Marc-Andre Laperle37de9712017-09-27 15:31:17 +000026#include "llvm/Support/Path.h"
Ilya Biryukovf01af682017-05-23 13:42:59 +000027#include "llvm/Support/raw_ostream.h"
28#include <future>
Ilya Biryukov38d79772017-05-16 09:38:59 +000029
Ilya Biryukov2f314102017-05-16 10:06:20 +000030using namespace clang;
Ilya Biryukov38d79772017-05-16 09:38:59 +000031using namespace clang::clangd;
32
Ilya Biryukovafb55542017-05-16 14:40:30 +000033namespace {
34
Ilya Biryukov75f1dd92018-01-31 08:51:16 +000035void ignoreError(llvm::Error Err) {
36 handleAllErrors(std::move(Err), [](const llvm::ErrorInfoBase &) {});
37}
38
Ilya Biryukova46f7a92017-06-28 10:34:50 +000039std::string getStandardResourceDir() {
40 static int Dummy; // Just an address in this process.
41 return CompilerInvocation::GetResourcesPath("clangd", (void *)&Dummy);
42}
43
Haojian Wu345099c2017-11-09 11:30:04 +000044class RefactoringResultCollector final
45 : public tooling::RefactoringResultConsumer {
46public:
47 void handleError(llvm::Error Err) override {
48 assert(!Result.hasValue());
49 // FIXME: figure out a way to return better message for DiagnosticError.
50 // clangd uses llvm::toString to convert the Err to string, however, for
51 // DiagnosticError, only "clang diagnostic" will be generated.
52 Result = std::move(Err);
53 }
54
55 // Using the handle(SymbolOccurrences) from parent class.
56 using tooling::RefactoringResultConsumer::handle;
57
58 void handle(tooling::AtomicChanges SourceReplacements) override {
59 assert(!Result.hasValue());
60 Result = std::move(SourceReplacements);
61 }
62
63 Optional<Expected<tooling::AtomicChanges>> Result;
64};
65
Ilya Biryukovafb55542017-05-16 14:40:30 +000066} // namespace
67
Ilya Biryukov22602992017-05-30 15:11:02 +000068Tagged<IntrusiveRefCntPtr<vfs::FileSystem>>
Ilya Biryukovaf0c04b2017-06-14 09:46:44 +000069RealFileSystemProvider::getTaggedFileSystem(PathRef File) {
Ilya Biryukov22602992017-05-30 15:11:02 +000070 return make_tagged(vfs::getRealFileSystem(), VFSTag());
Ilya Biryukov0f62ed22017-05-26 12:26:51 +000071}
72
Sam McCall7363a2f2018-03-05 17:28:54 +000073ClangdServer::Options ClangdServer::optsForTest() {
74 ClangdServer::Options Opts;
75 Opts.UpdateDebounce = std::chrono::steady_clock::duration::zero(); // Faster!
76 Opts.StorePreamblesInMemory = true;
77 Opts.AsyncThreadsCount = 4; // Consistent!
78 return Opts;
79}
80
Sam McCalladccab62017-11-23 16:58:22 +000081ClangdServer::ClangdServer(GlobalCompilationDatabase &CDB,
Sam McCalladccab62017-11-23 16:58:22 +000082 FileSystemProvider &FSProvider,
Sam McCall7363a2f2018-03-05 17:28:54 +000083 DiagnosticsConsumer &DiagConsumer,
84 const Options &Opts)
85 : CompileArgs(CDB, Opts.ResourceDir ? Opts.ResourceDir->str()
86 : getStandardResourceDir()),
Ilya Biryukov929697b2018-01-25 14:19:21 +000087 DiagConsumer(DiagConsumer), FSProvider(FSProvider),
Sam McCall7363a2f2018-03-05 17:28:54 +000088 FileIdx(Opts.BuildDynamicSymbolIndex ? new FileIndex() : nullptr),
Ilya Biryukov75f1dd92018-01-31 08:51:16 +000089 PCHs(std::make_shared<PCHContainerOperations>()),
90 // Pass a callback into `WorkScheduler` to extract symbols from a newly
91 // parsed file and rebuild the file index synchronously each time an AST
92 // is parsed.
Eric Liubfac8f72017-12-19 18:00:37 +000093 // FIXME(ioeric): this can be slow and we may be able to index on less
94 // critical paths.
Sam McCall7363a2f2018-03-05 17:28:54 +000095 WorkScheduler(Opts.AsyncThreadsCount, Opts.StorePreamblesInMemory,
Sam McCalld1a7a372018-01-31 13:40:48 +000096 FileIdx
97 ? [this](PathRef Path,
98 ParsedAST *AST) { FileIdx->update(Path, AST); }
Sam McCalld1e0deb2018-03-02 08:56:37 +000099 : ASTParsedCallback(),
Sam McCall7363a2f2018-03-05 17:28:54 +0000100 Opts.UpdateDebounce) {
101 if (FileIdx && Opts.StaticIndex) {
102 MergedIndex = mergeIndex(FileIdx.get(), Opts.StaticIndex);
Sam McCall0faecf02018-01-15 12:33:00 +0000103 Index = MergedIndex.get();
104 } else if (FileIdx)
105 Index = FileIdx.get();
Sam McCall7363a2f2018-03-05 17:28:54 +0000106 else if (Opts.StaticIndex)
107 Index = Opts.StaticIndex;
Sam McCall0faecf02018-01-15 12:33:00 +0000108 else
109 Index = nullptr;
110}
Ilya Biryukov38d79772017-05-16 09:38:59 +0000111
Marc-Andre Laperle37de9712017-09-27 15:31:17 +0000112void ClangdServer::setRootPath(PathRef RootPath) {
113 std::string NewRootPath = llvm::sys::path::convert_to_slash(
114 RootPath, llvm::sys::path::Style::posix);
115 if (llvm::sys::fs::is_directory(NewRootPath))
116 this->RootPath = NewRootPath;
117}
118
Sam McCall568e17f2018-02-22 13:11:12 +0000119void ClangdServer::addDocument(PathRef File, StringRef Contents,
120 WantDiagnostics WantDiags) {
Ilya Biryukovf01af682017-05-23 13:42:59 +0000121 DocVersion Version = DraftMgr.updateDraft(File, Contents);
Ilya Biryukov02d58702017-08-01 15:51:38 +0000122 auto TaggedFS = FSProvider.getTaggedFileSystem(File);
Sam McCall0bb24cd2018-02-13 08:59:23 +0000123 scheduleReparseAndDiags(File, VersionedDraft{Version, Contents.str()},
Sam McCall568e17f2018-02-22 13:11:12 +0000124 WantDiags, std::move(TaggedFS));
Ilya Biryukov38d79772017-05-16 09:38:59 +0000125}
126
Ilya Biryukov7e5ee262018-02-08 07:37:35 +0000127void ClangdServer::removeDocument(PathRef File) {
Ilya Biryukovc5ad35f2017-08-14 08:17:24 +0000128 DraftMgr.removeDraft(File);
Ilya Biryukov929697b2018-01-25 14:19:21 +0000129 CompileArgs.invalidate(File);
Ilya Biryukov7e5ee262018-02-08 07:37:35 +0000130 WorkScheduler.remove(File);
Ilya Biryukov38d79772017-05-16 09:38:59 +0000131}
132
Sam McCall0bb24cd2018-02-13 08:59:23 +0000133void ClangdServer::forceReparse(PathRef File) {
Ilya Biryukov91dbf5b2017-08-14 08:37:32 +0000134 auto FileContents = DraftMgr.getDraft(File);
135 assert(FileContents.Draft &&
136 "forceReparse() was called for non-added document");
137
Ilya Biryukov929697b2018-01-25 14:19:21 +0000138 // forceReparse promises to request new compilation flags from CDB, so we
139 // remove any cahced flags.
140 CompileArgs.invalidate(File);
141
Ilya Biryukov91dbf5b2017-08-14 08:37:32 +0000142 auto TaggedFS = FSProvider.getTaggedFileSystem(File);
Sam McCall568e17f2018-02-22 13:11:12 +0000143 scheduleReparseAndDiags(File, std::move(FileContents), WantDiagnostics::Yes,
144 std::move(TaggedFS));
Ilya Biryukov0f62ed22017-05-26 12:26:51 +0000145}
146
Ilya Biryukov90bbcfd2017-10-25 09:35:10 +0000147void ClangdServer::codeComplete(
Sam McCalld1a7a372018-01-31 13:40:48 +0000148 PathRef File, Position Pos, const clangd::CodeCompleteOptions &Opts,
149 UniqueFunction<void(Tagged<CompletionList>)> Callback,
Ilya Biryukov90bbcfd2017-10-25 09:35:10 +0000150 IntrusiveRefCntPtr<vfs::FileSystem> *UsedFS) {
Sam McCalld1a7a372018-01-31 13:40:48 +0000151 using CallbackType = UniqueFunction<void(Tagged<CompletionList>)>;
Ilya Biryukov90bbcfd2017-10-25 09:35:10 +0000152
Ilya Biryukovaf0c04b2017-06-14 09:46:44 +0000153 auto TaggedFS = FSProvider.getTaggedFileSystem(File);
Ilya Biryukoved99e4c2017-07-31 17:09:29 +0000154 if (UsedFS)
155 *UsedFS = TaggedFS.Value;
156
Ilya Biryukovd3b04e32017-12-05 10:42:57 +0000157 // Copy completion options for passing them to async task handler.
158 auto CodeCompleteOpts = Opts;
Sam McCall0faecf02018-01-15 12:33:00 +0000159 if (!CodeCompleteOpts.Index) // Respect overridden index.
160 CodeCompleteOpts.Index = Index;
Ilya Biryukovf6e2b4c2018-01-09 14:39:27 +0000161
Sam McCalldb3ea4c2018-02-27 17:15:50 +0000162 VersionedDraft Latest = DraftMgr.getDraft(File);
163 // FIXME(sammccall): return error for consistency?
164 assert(Latest.Draft && "codeComplete called for non-added document");
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000165
Ilya Biryukovf6e2b4c2018-01-09 14:39:27 +0000166 // Copy PCHs to avoid accessing this->PCHs concurrently
167 std::shared_ptr<PCHContainerOperations> PCHs = this->PCHs;
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000168 auto Task = [PCHs, Pos, TaggedFS, CodeCompleteOpts](
Sam McCalld1a7a372018-01-31 13:40:48 +0000169 std::string Contents, Path File, CallbackType Callback,
170 llvm::Expected<InputsAndPreamble> IP) {
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000171 assert(IP && "error when trying to read preamble for codeComplete");
172 auto PreambleData = IP->Preamble;
173 auto &Command = IP->Inputs.CompileCommand;
Ilya Biryukovdcd21692017-10-05 17:04:13 +0000174
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000175 // FIXME(ibiryukov): even if Preamble is non-null, we may want to check
176 // both the old and the new version in case only one of them matches.
177 CompletionList Result = clangd::codeComplete(
Sam McCalld1a7a372018-01-31 13:40:48 +0000178 File, Command, PreambleData ? &PreambleData->Preamble : nullptr,
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000179 Contents, Pos, TaggedFS.Value, PCHs, CodeCompleteOpts);
Ilya Biryukov90bbcfd2017-10-25 09:35:10 +0000180
Sam McCalld1a7a372018-01-31 13:40:48 +0000181 Callback(make_tagged(std::move(Result), std::move(TaggedFS.Tag)));
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000182 };
183
Sam McCall091557d2018-02-23 07:54:17 +0000184 WorkScheduler.runWithPreamble(
185 "CodeComplete", File,
Sam McCalldb3ea4c2018-02-27 17:15:50 +0000186 Bind(Task, std::move(*Latest.Draft), File.str(), std::move(Callback)));
Ilya Biryukov38d79772017-05-16 09:38:59 +0000187}
Ilya Biryukovf01af682017-05-23 13:42:59 +0000188
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000189void ClangdServer::signatureHelp(
190 PathRef File, Position Pos,
191 UniqueFunction<void(llvm::Expected<Tagged<SignatureHelp>>)> Callback,
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000192 IntrusiveRefCntPtr<vfs::FileSystem> *UsedFS) {
Ilya Biryukovd9bdfe02017-10-06 11:54:17 +0000193 auto TaggedFS = FSProvider.getTaggedFileSystem(File);
194 if (UsedFS)
195 *UsedFS = TaggedFS.Value;
196
Sam McCalldb3ea4c2018-02-27 17:15:50 +0000197 VersionedDraft Latest = DraftMgr.getDraft(File);
198 if (!Latest.Draft)
199 return Callback(llvm::make_error<llvm::StringError>(
200 "signatureHelp is called for non-added document",
201 llvm::errc::invalid_argument));
Ilya Biryukovd9bdfe02017-10-06 11:54:17 +0000202
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000203 auto PCHs = this->PCHs;
Sam McCalldb3ea4c2018-02-27 17:15:50 +0000204 auto Action = [Pos, TaggedFS, PCHs](std::string Contents, Path File,
205 decltype(Callback) Callback,
206 llvm::Expected<InputsAndPreamble> IP) {
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000207 if (!IP)
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000208 return Callback(IP.takeError());
209
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000210 auto PreambleData = IP->Preamble;
211 auto &Command = IP->Inputs.CompileCommand;
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000212 Callback(make_tagged(
Sam McCalld1a7a372018-01-31 13:40:48 +0000213 clangd::signatureHelp(File, Command,
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000214 PreambleData ? &PreambleData->Preamble : nullptr,
215 Contents, Pos, TaggedFS.Value, PCHs),
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000216 TaggedFS.Tag));
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000217 };
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000218
Sam McCalldb3ea4c2018-02-27 17:15:50 +0000219 WorkScheduler.runWithPreamble(
220 "SignatureHelp", File,
221 Bind(Action, std::move(*Latest.Draft), File.str(), std::move(Callback)));
Ilya Biryukovd9bdfe02017-10-06 11:54:17 +0000222}
223
Raoul Wols212bcf82017-12-12 20:25:06 +0000224llvm::Expected<tooling::Replacements>
225ClangdServer::formatRange(StringRef Code, PathRef File, Range Rng) {
Ilya Biryukovafb55542017-05-16 14:40:30 +0000226 size_t Begin = positionToOffset(Code, Rng.start);
227 size_t Len = positionToOffset(Code, Rng.end) - Begin;
228 return formatCode(Code, File, {tooling::Range(Begin, Len)});
229}
230
Raoul Wols212bcf82017-12-12 20:25:06 +0000231llvm::Expected<tooling::Replacements> ClangdServer::formatFile(StringRef Code,
232 PathRef File) {
Ilya Biryukovafb55542017-05-16 14:40:30 +0000233 // Format everything.
Ilya Biryukovafb55542017-05-16 14:40:30 +0000234 return formatCode(Code, File, {tooling::Range(0, Code.size())});
235}
236
Raoul Wols212bcf82017-12-12 20:25:06 +0000237llvm::Expected<tooling::Replacements>
238ClangdServer::formatOnType(StringRef Code, PathRef File, Position Pos) {
Ilya Biryukovafb55542017-05-16 14:40:30 +0000239 // Look for the previous opening brace from the character position and
240 // format starting from there.
Ilya Biryukovafb55542017-05-16 14:40:30 +0000241 size_t CursorPos = positionToOffset(Code, Pos);
242 size_t PreviousLBracePos = StringRef(Code).find_last_of('{', CursorPos);
243 if (PreviousLBracePos == StringRef::npos)
244 PreviousLBracePos = CursorPos;
Sam McCallb536a2a2017-12-19 12:23:48 +0000245 size_t Len = CursorPos - PreviousLBracePos;
Ilya Biryukovafb55542017-05-16 14:40:30 +0000246
247 return formatCode(Code, File, {tooling::Range(PreviousLBracePos, Len)});
248}
Ilya Biryukov38d79772017-05-16 09:38:59 +0000249
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000250void ClangdServer::rename(
251 PathRef File, Position Pos, llvm::StringRef NewName,
252 UniqueFunction<void(Expected<std::vector<tooling::Replacement>>)>
253 Callback) {
254 auto Action = [Pos](Path File, std::string NewName,
255 decltype(Callback) Callback,
256 Expected<InputsAndAST> InpAST) {
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000257 if (!InpAST)
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000258 return Callback(InpAST.takeError());
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000259 auto &AST = InpAST->AST;
260
261 RefactoringResultCollector ResultCollector;
262 const SourceManager &SourceMgr = AST.getASTContext().getSourceManager();
Haojian Wu345099c2017-11-09 11:30:04 +0000263 const FileEntry *FE =
264 SourceMgr.getFileEntryForID(SourceMgr.getMainFileID());
265 if (!FE)
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000266 return Callback(llvm::make_error<llvm::StringError>(
267 "rename called for non-added document",
268 llvm::errc::invalid_argument));
Haojian Wu345099c2017-11-09 11:30:04 +0000269 SourceLocation SourceLocationBeg =
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000270 clangd::getBeginningOfIdentifier(AST, Pos, FE);
Haojian Wu345099c2017-11-09 11:30:04 +0000271 tooling::RefactoringRuleContext Context(
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000272 AST.getASTContext().getSourceManager());
273 Context.setASTContext(AST.getASTContext());
Haojian Wu345099c2017-11-09 11:30:04 +0000274 auto Rename = clang::tooling::RenameOccurrences::initiate(
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000275 Context, SourceRange(SourceLocationBeg), NewName);
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000276 if (!Rename)
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000277 return Callback(Rename.takeError());
Haojian Wu345099c2017-11-09 11:30:04 +0000278
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000279 Rename->invoke(ResultCollector, Context);
280
281 assert(ResultCollector.Result.hasValue());
282 if (!ResultCollector.Result.getValue())
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000283 return Callback(ResultCollector.Result->takeError());
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000284
285 std::vector<tooling::Replacement> Replacements;
286 for (const tooling::AtomicChange &Change : ResultCollector.Result->get()) {
287 tooling::Replacements ChangeReps = Change.getReplacements();
288 for (const auto &Rep : ChangeReps) {
289 // FIXME: Right now we only support renaming the main file, so we
290 // drop replacements not for the main file. In the future, we might
291 // consider to support:
292 // * rename in any included header
293 // * rename only in the "main" header
294 // * provide an error if there are symbols we won't rename (e.g.
295 // std::vector)
296 // * rename globally in project
297 // * rename in open files
298 if (Rep.getFilePath() == File)
299 Replacements.push_back(Rep);
300 }
Haojian Wu345099c2017-11-09 11:30:04 +0000301 }
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000302 return Callback(Replacements);
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000303 };
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000304
305 WorkScheduler.runWithAST(
Sam McCallc901c5d2018-02-19 09:56:28 +0000306 "Rename", File,
Sam McCall091557d2018-02-23 07:54:17 +0000307 Bind(Action, File.str(), NewName.str(), std::move(Callback)));
Haojian Wu345099c2017-11-09 11:30:04 +0000308}
309
Eric Liu6c8e8582018-02-26 08:32:13 +0000310/// Creates a `HeaderFile` from \p Header which can be either a URI or a literal
311/// include.
312static llvm::Expected<HeaderFile> toHeaderFile(StringRef Header,
313 llvm::StringRef HintPath) {
314 if (isLiteralInclude(Header))
315 return HeaderFile{Header.str(), /*Verbatim=*/true};
316 auto U = URI::parse(Header);
317 if (!U)
318 return U.takeError();
319 auto Resolved = URI::resolve(*U, HintPath);
320 if (!Resolved)
321 return Resolved.takeError();
322 return HeaderFile{std::move(*Resolved), /*Verbatim=*/false};
323};
324
Eric Liuc5105f92018-02-16 14:15:55 +0000325Expected<tooling::Replacements>
326ClangdServer::insertInclude(PathRef File, StringRef Code,
Eric Liu6c8e8582018-02-26 08:32:13 +0000327 StringRef DeclaringHeader,
328 StringRef InsertedHeader) {
329 assert(!DeclaringHeader.empty() && !InsertedHeader.empty());
Eric Liuc5105f92018-02-16 14:15:55 +0000330 std::string ToInclude;
Eric Liu6c8e8582018-02-26 08:32:13 +0000331 auto ResolvedOrginal = toHeaderFile(DeclaringHeader, File);
332 if (!ResolvedOrginal)
333 return ResolvedOrginal.takeError();
334 auto ResolvedPreferred = toHeaderFile(InsertedHeader, File);
335 if (!ResolvedPreferred)
336 return ResolvedPreferred.takeError();
337 tooling::CompileCommand CompileCommand = CompileArgs.getCompileCommand(File);
338 auto Include = calculateIncludePath(
339 File, Code, *ResolvedOrginal, *ResolvedPreferred, CompileCommand,
340 FSProvider.getTaggedFileSystem(File).Value);
341 if (!Include)
342 return Include.takeError();
343 if (Include->empty())
344 return tooling::Replacements();
345 ToInclude = std::move(*Include);
Eric Liuc5105f92018-02-16 14:15:55 +0000346
347 auto Style = format::getStyle("file", File, "llvm");
348 if (!Style) {
349 llvm::consumeError(Style.takeError());
350 // FIXME(ioeric): needs more consistent style support in clangd server.
351 Style = format::getLLVMStyle();
352 }
353 // Replacement with offset UINT_MAX and length 0 will be treated as include
354 // insertion.
355 tooling::Replacement R(File, /*Offset=*/UINT_MAX, 0, "#include " + ToInclude);
356 return format::cleanupAroundReplacements(Code, tooling::Replacements(R),
357 *Style);
358}
359
Ilya Biryukov261c72e2018-01-17 12:30:24 +0000360llvm::Optional<std::string> ClangdServer::getDocument(PathRef File) {
361 auto Latest = DraftMgr.getDraft(File);
362 if (!Latest.Draft)
363 return llvm::None;
364 return std::move(*Latest.Draft);
Ilya Biryukov38d79772017-05-16 09:38:59 +0000365}
366
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000367void ClangdServer::dumpAST(PathRef File,
368 UniqueFunction<void(std::string)> Callback) {
369 auto Action = [](decltype(Callback) Callback,
370 llvm::Expected<InputsAndAST> InpAST) {
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000371 if (!InpAST) {
372 ignoreError(InpAST.takeError());
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000373 return Callback("<no-ast>");
Ilya Biryukov02d58702017-08-01 15:51:38 +0000374 }
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000375 std::string Result;
376
377 llvm::raw_string_ostream ResultOS(Result);
378 clangd::dumpAST(InpAST->AST, ResultOS);
Ilya Biryukov02d58702017-08-01 15:51:38 +0000379 ResultOS.flush();
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000380
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000381 Callback(Result);
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000382 };
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000383
Sam McCall091557d2018-02-23 07:54:17 +0000384 WorkScheduler.runWithAST("DumpAST", File, Bind(Action, std::move(Callback)));
Ilya Biryukov38d79772017-05-16 09:38:59 +0000385}
Marc-Andre Laperle2cbf0372017-06-28 16:12:10 +0000386
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000387void ClangdServer::findDefinitions(
388 PathRef File, Position Pos,
389 UniqueFunction<void(llvm::Expected<Tagged<std::vector<Location>>>)>
390 Callback) {
Ilya Biryukov02d58702017-08-01 15:51:38 +0000391 auto TaggedFS = FSProvider.getTaggedFileSystem(File);
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000392 auto Action = [Pos, TaggedFS](decltype(Callback) Callback,
393 llvm::Expected<InputsAndAST> InpAST) {
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000394 if (!InpAST)
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000395 return Callback(InpAST.takeError());
Sam McCalld1a7a372018-01-31 13:40:48 +0000396 auto Result = clangd::findDefinitions(InpAST->AST, Pos);
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000397 Callback(make_tagged(std::move(Result), TaggedFS.Tag));
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000398 };
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000399
Sam McCallc901c5d2018-02-19 09:56:28 +0000400 WorkScheduler.runWithAST("Definitions", File,
Sam McCall091557d2018-02-23 07:54:17 +0000401 Bind(Action, std::move(Callback)));
Marc-Andre Laperle2cbf0372017-06-28 16:12:10 +0000402}
Ilya Biryukovc5ad35f2017-08-14 08:17:24 +0000403
Marc-Andre Laperle6571b3e2017-09-28 03:14:40 +0000404llvm::Optional<Path> ClangdServer::switchSourceHeader(PathRef Path) {
405
406 StringRef SourceExtensions[] = {".cpp", ".c", ".cc", ".cxx",
407 ".c++", ".m", ".mm"};
408 StringRef HeaderExtensions[] = {".h", ".hh", ".hpp", ".hxx", ".inc"};
409
410 StringRef PathExt = llvm::sys::path::extension(Path);
411
412 // Lookup in a list of known extensions.
413 auto SourceIter =
414 std::find_if(std::begin(SourceExtensions), std::end(SourceExtensions),
415 [&PathExt](PathRef SourceExt) {
416 return SourceExt.equals_lower(PathExt);
417 });
418 bool IsSource = SourceIter != std::end(SourceExtensions);
419
420 auto HeaderIter =
421 std::find_if(std::begin(HeaderExtensions), std::end(HeaderExtensions),
422 [&PathExt](PathRef HeaderExt) {
423 return HeaderExt.equals_lower(PathExt);
424 });
425
426 bool IsHeader = HeaderIter != std::end(HeaderExtensions);
427
428 // We can only switch between extensions known extensions.
429 if (!IsSource && !IsHeader)
430 return llvm::None;
431
432 // Array to lookup extensions for the switch. An opposite of where original
433 // extension was found.
434 ArrayRef<StringRef> NewExts;
435 if (IsSource)
436 NewExts = HeaderExtensions;
437 else
438 NewExts = SourceExtensions;
439
440 // Storage for the new path.
441 SmallString<128> NewPath = StringRef(Path);
442
443 // Instance of vfs::FileSystem, used for file existence checks.
444 auto FS = FSProvider.getTaggedFileSystem(Path).Value;
445
446 // Loop through switched extension candidates.
447 for (StringRef NewExt : NewExts) {
448 llvm::sys::path::replace_extension(NewPath, NewExt);
449 if (FS->exists(NewPath))
450 return NewPath.str().str(); // First str() to convert from SmallString to
451 // StringRef, second to convert from StringRef
452 // to std::string
Ilya Biryukov33334942017-10-06 14:39:39 +0000453
Marc-Andre Laperle6571b3e2017-09-28 03:14:40 +0000454 // Also check NewExt in upper-case, just in case.
455 llvm::sys::path::replace_extension(NewPath, NewExt.upper());
456 if (FS->exists(NewPath))
457 return NewPath.str().str();
Marc-Andre Laperle6571b3e2017-09-28 03:14:40 +0000458 }
459
460 return llvm::None;
461}
462
Raoul Wols212bcf82017-12-12 20:25:06 +0000463llvm::Expected<tooling::Replacements>
464ClangdServer::formatCode(llvm::StringRef Code, PathRef File,
465 ArrayRef<tooling::Range> Ranges) {
466 // Call clang-format.
467 auto TaggedFS = FSProvider.getTaggedFileSystem(File);
468 auto StyleOrError =
469 format::getStyle("file", File, "LLVM", Code, TaggedFS.Value.get());
470 if (!StyleOrError) {
471 return StyleOrError.takeError();
472 } else {
473 return format::reformat(StyleOrError.get(), Code, Ranges, File);
474 }
475}
476
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000477void ClangdServer::findDocumentHighlights(
478 PathRef File, Position Pos,
479 UniqueFunction<void(llvm::Expected<Tagged<std::vector<DocumentHighlight>>>)>
480 Callback) {
Ilya Biryukov0e6a51f2017-12-12 12:27:47 +0000481 auto FileContents = DraftMgr.getDraft(File);
482 if (!FileContents.Draft)
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000483 return Callback(llvm::make_error<llvm::StringError>(
Ilya Biryukov0e6a51f2017-12-12 12:27:47 +0000484 "findDocumentHighlights called on non-added file",
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000485 llvm::errc::invalid_argument));
Ilya Biryukov0e6a51f2017-12-12 12:27:47 +0000486
487 auto TaggedFS = FSProvider.getTaggedFileSystem(File);
488
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000489 auto Action = [TaggedFS, Pos](decltype(Callback) Callback,
490 llvm::Expected<InputsAndAST> InpAST) {
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000491 if (!InpAST)
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000492 return Callback(InpAST.takeError());
Sam McCalld1a7a372018-01-31 13:40:48 +0000493 auto Result = clangd::findDocumentHighlights(InpAST->AST, Pos);
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000494 Callback(make_tagged(std::move(Result), TaggedFS.Tag));
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000495 };
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000496
Sam McCallc901c5d2018-02-19 09:56:28 +0000497 WorkScheduler.runWithAST("Highlights", File,
Sam McCall091557d2018-02-23 07:54:17 +0000498 Bind(Action, std::move(Callback)));
Ilya Biryukov0e6a51f2017-12-12 12:27:47 +0000499}
500
Marc-Andre Laperle3e618ed2018-02-16 21:38:15 +0000501void ClangdServer::findHover(
502 PathRef File, Position Pos,
503 UniqueFunction<void(llvm::Expected<Tagged<Hover>>)> Callback) {
504 Hover FinalHover;
505 auto FileContents = DraftMgr.getDraft(File);
506 if (!FileContents.Draft)
507 return Callback(llvm::make_error<llvm::StringError>(
508 "findHover called on non-added file", llvm::errc::invalid_argument));
509
510 auto TaggedFS = FSProvider.getTaggedFileSystem(File);
511
512 auto Action = [Pos, TaggedFS](decltype(Callback) Callback,
513 llvm::Expected<InputsAndAST> InpAST) {
514 if (!InpAST)
515 return Callback(InpAST.takeError());
516
517 Hover Result = clangd::getHover(InpAST->AST, Pos);
518 Callback(make_tagged(std::move(Result), TaggedFS.Tag));
519 };
520
Sam McCall091557d2018-02-23 07:54:17 +0000521 WorkScheduler.runWithAST("Hover", File, Bind(Action, std::move(Callback)));
Marc-Andre Laperle3e618ed2018-02-16 21:38:15 +0000522}
523
Sam McCall0bb24cd2018-02-13 08:59:23 +0000524void ClangdServer::scheduleReparseAndDiags(
Sam McCall568e17f2018-02-22 13:11:12 +0000525 PathRef File, VersionedDraft Contents, WantDiagnostics WantDiags,
Ilya Biryukov929697b2018-01-25 14:19:21 +0000526 Tagged<IntrusiveRefCntPtr<vfs::FileSystem>> TaggedFS) {
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000527 tooling::CompileCommand Command = CompileArgs.getCompileCommand(File);
Ilya Biryukov929697b2018-01-25 14:19:21 +0000528
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000529 DocVersion Version = Contents.Version;
530 Path FileStr = File.str();
531 VFSTag Tag = std::move(TaggedFS.Tag);
532
Sam McCall568e17f2018-02-22 13:11:12 +0000533 auto Callback = [this, Version, FileStr,
534 Tag](std::vector<DiagWithFixIts> Diags) {
Ilya Biryukov47f22022017-09-20 12:58:55 +0000535 // We need to serialize access to resulting diagnostics to avoid calling
536 // `onDiagnosticsReady` in the wrong order.
537 std::lock_guard<std::mutex> DiagsLock(DiagnosticsMutex);
538 DocVersion &LastReportedDiagsVersion = ReportedDiagnosticVersions[FileStr];
539 // FIXME(ibiryukov): get rid of '<' comparison here. In the current
540 // implementation diagnostics will not be reported after version counters'
541 // overflow. This should not happen in practice, since DocVersion is a
542 // 64-bit unsigned integer.
543 if (Version < LastReportedDiagsVersion)
544 return;
545 LastReportedDiagsVersion = Version;
546
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000547 DiagConsumer.onDiagnosticsReady(
Sam McCall568e17f2018-02-22 13:11:12 +0000548 FileStr, make_tagged(std::move(Diags), std::move(Tag)));
Ilya Biryukovc5ad35f2017-08-14 08:17:24 +0000549 };
550
Sam McCalld1a7a372018-01-31 13:40:48 +0000551 WorkScheduler.update(File,
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000552 ParseInputs{std::move(Command),
553 std::move(TaggedFS.Value),
554 std::move(*Contents.Draft)},
Sam McCall568e17f2018-02-22 13:11:12 +0000555 WantDiags, std::move(Callback));
Ilya Biryukovc5ad35f2017-08-14 08:17:24 +0000556}
Marc-Andre Laperlebf114242017-10-02 18:00:37 +0000557
Simon Marchi5178f922018-02-22 14:00:39 +0000558void ClangdServer::reparseOpenedFiles() {
559 for (const Path &FilePath : DraftMgr.getActiveFiles())
560 forceReparse(FilePath);
561}
562
Marc-Andre Laperlebf114242017-10-02 18:00:37 +0000563void ClangdServer::onFileEvent(const DidChangeWatchedFilesParams &Params) {
564 // FIXME: Do nothing for now. This will be used for indexing and potentially
565 // invalidating other caches.
566}
Ilya Biryukovdf842342018-01-25 14:32:21 +0000567
568std::vector<std::pair<Path, std::size_t>>
569ClangdServer::getUsedBytesPerFile() const {
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000570 return WorkScheduler.getUsedBytesPerFile();
Ilya Biryukovdf842342018-01-25 14:32:21 +0000571}
Sam McCall0bb24cd2018-02-13 08:59:23 +0000572
573LLVM_NODISCARD bool
574ClangdServer::blockUntilIdleForTest(llvm::Optional<double> TimeoutSeconds) {
575 return WorkScheduler.blockUntilIdle(timeoutSeconds(TimeoutSeconds));
576}