blob: a306ed2288cf4c852193260fe009e6cc1671e0ce [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 McCalladccab62017-11-23 16:58:22 +000073ClangdServer::ClangdServer(GlobalCompilationDatabase &CDB,
74 DiagnosticsConsumer &DiagConsumer,
75 FileSystemProvider &FSProvider,
76 unsigned AsyncThreadsCount,
Ilya Biryukov940901e2017-12-13 12:51:22 +000077 bool StorePreamblesInMemory,
Haojian Wuba28e9a2018-01-10 14:44:34 +000078 bool BuildDynamicSymbolIndex, SymbolIndex *StaticIdx,
Sam McCalladccab62017-11-23 16:58:22 +000079 llvm::Optional<StringRef> ResourceDir)
Ilya Biryukov929697b2018-01-25 14:19:21 +000080 : CompileArgs(CDB,
81 ResourceDir ? ResourceDir->str() : getStandardResourceDir()),
82 DiagConsumer(DiagConsumer), FSProvider(FSProvider),
Eric Liubfac8f72017-12-19 18:00:37 +000083 FileIdx(BuildDynamicSymbolIndex ? new FileIndex() : nullptr),
Ilya Biryukov75f1dd92018-01-31 08:51:16 +000084 PCHs(std::make_shared<PCHContainerOperations>()),
85 // Pass a callback into `WorkScheduler` to extract symbols from a newly
86 // parsed file and rebuild the file index synchronously each time an AST
87 // is parsed.
Eric Liubfac8f72017-12-19 18:00:37 +000088 // FIXME(ioeric): this can be slow and we may be able to index on less
89 // critical paths.
Sam McCalld1a7a372018-01-31 13:40:48 +000090 WorkScheduler(AsyncThreadsCount, StorePreamblesInMemory,
91 FileIdx
92 ? [this](PathRef Path,
93 ParsedAST *AST) { FileIdx->update(Path, AST); }
94 : ASTParsedCallback()) {
Sam McCall0faecf02018-01-15 12:33:00 +000095 if (FileIdx && StaticIdx) {
96 MergedIndex = mergeIndex(FileIdx.get(), StaticIdx);
97 Index = MergedIndex.get();
98 } else if (FileIdx)
99 Index = FileIdx.get();
100 else if (StaticIdx)
101 Index = StaticIdx;
102 else
103 Index = nullptr;
104}
Ilya Biryukov38d79772017-05-16 09:38:59 +0000105
Marc-Andre Laperle37de9712017-09-27 15:31:17 +0000106void ClangdServer::setRootPath(PathRef RootPath) {
107 std::string NewRootPath = llvm::sys::path::convert_to_slash(
108 RootPath, llvm::sys::path::Style::posix);
109 if (llvm::sys::fs::is_directory(NewRootPath))
110 this->RootPath = NewRootPath;
111}
112
Sam McCall568e17f2018-02-22 13:11:12 +0000113void ClangdServer::addDocument(PathRef File, StringRef Contents,
114 WantDiagnostics WantDiags) {
Ilya Biryukovf01af682017-05-23 13:42:59 +0000115 DocVersion Version = DraftMgr.updateDraft(File, Contents);
Ilya Biryukov02d58702017-08-01 15:51:38 +0000116 auto TaggedFS = FSProvider.getTaggedFileSystem(File);
Sam McCall0bb24cd2018-02-13 08:59:23 +0000117 scheduleReparseAndDiags(File, VersionedDraft{Version, Contents.str()},
Sam McCall568e17f2018-02-22 13:11:12 +0000118 WantDiags, std::move(TaggedFS));
Ilya Biryukov38d79772017-05-16 09:38:59 +0000119}
120
Ilya Biryukov7e5ee262018-02-08 07:37:35 +0000121void ClangdServer::removeDocument(PathRef File) {
Ilya Biryukovc5ad35f2017-08-14 08:17:24 +0000122 DraftMgr.removeDraft(File);
Ilya Biryukov929697b2018-01-25 14:19:21 +0000123 CompileArgs.invalidate(File);
Ilya Biryukov7e5ee262018-02-08 07:37:35 +0000124 WorkScheduler.remove(File);
Ilya Biryukov38d79772017-05-16 09:38:59 +0000125}
126
Sam McCall0bb24cd2018-02-13 08:59:23 +0000127void ClangdServer::forceReparse(PathRef File) {
Ilya Biryukov91dbf5b2017-08-14 08:37:32 +0000128 auto FileContents = DraftMgr.getDraft(File);
129 assert(FileContents.Draft &&
130 "forceReparse() was called for non-added document");
131
Ilya Biryukov929697b2018-01-25 14:19:21 +0000132 // forceReparse promises to request new compilation flags from CDB, so we
133 // remove any cahced flags.
134 CompileArgs.invalidate(File);
135
Ilya Biryukov91dbf5b2017-08-14 08:37:32 +0000136 auto TaggedFS = FSProvider.getTaggedFileSystem(File);
Sam McCall568e17f2018-02-22 13:11:12 +0000137 scheduleReparseAndDiags(File, std::move(FileContents), WantDiagnostics::Yes,
138 std::move(TaggedFS));
Ilya Biryukov0f62ed22017-05-26 12:26:51 +0000139}
140
Ilya Biryukov90bbcfd2017-10-25 09:35:10 +0000141void ClangdServer::codeComplete(
Sam McCalld1a7a372018-01-31 13:40:48 +0000142 PathRef File, Position Pos, const clangd::CodeCompleteOptions &Opts,
143 UniqueFunction<void(Tagged<CompletionList>)> Callback,
Ilya Biryukovd3b04e32017-12-05 10:42:57 +0000144 llvm::Optional<StringRef> OverridenContents,
Ilya Biryukov90bbcfd2017-10-25 09:35:10 +0000145 IntrusiveRefCntPtr<vfs::FileSystem> *UsedFS) {
Sam McCalld1a7a372018-01-31 13:40:48 +0000146 using CallbackType = UniqueFunction<void(Tagged<CompletionList>)>;
Ilya Biryukov90bbcfd2017-10-25 09:35:10 +0000147
Ilya Biryukovaf0c04b2017-06-14 09:46:44 +0000148 auto TaggedFS = FSProvider.getTaggedFileSystem(File);
Ilya Biryukoved99e4c2017-07-31 17:09:29 +0000149 if (UsedFS)
150 *UsedFS = TaggedFS.Value;
151
Ilya Biryukovd3b04e32017-12-05 10:42:57 +0000152 // Copy completion options for passing them to async task handler.
153 auto CodeCompleteOpts = Opts;
Sam McCall0faecf02018-01-15 12:33:00 +0000154 if (!CodeCompleteOpts.Index) // Respect overridden index.
155 CodeCompleteOpts.Index = Index;
Ilya Biryukovf6e2b4c2018-01-09 14:39:27 +0000156
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000157 std::string Contents;
158 if (OverridenContents) {
159 Contents = OverridenContents->str();
160 } else {
161 VersionedDraft Latest = DraftMgr.getDraft(File);
162 assert(Latest.Draft && "codeComplete called for non-added document");
163 Contents = *Latest.Draft;
164 }
165
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,
186 Bind(Task, std::move(Contents), 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,
192 llvm::Optional<StringRef> OverridenContents,
193 IntrusiveRefCntPtr<vfs::FileSystem> *UsedFS) {
Ilya Biryukovd9bdfe02017-10-06 11:54:17 +0000194 auto TaggedFS = FSProvider.getTaggedFileSystem(File);
195 if (UsedFS)
196 *UsedFS = TaggedFS.Value;
197
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000198 std::string Contents;
199 if (OverridenContents) {
200 Contents = OverridenContents->str();
201 } else {
202 VersionedDraft Latest = DraftMgr.getDraft(File);
203 if (!Latest.Draft)
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000204 return Callback(llvm::make_error<llvm::StringError>(
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000205 "signatureHelp is called for non-added document",
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000206 llvm::errc::invalid_argument));
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000207 Contents = std::move(*Latest.Draft);
208 }
Ilya Biryukovd9bdfe02017-10-06 11:54:17 +0000209
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000210 auto PCHs = this->PCHs;
211 auto Action = [Contents, Pos, TaggedFS,
212 PCHs](Path File, decltype(Callback) Callback,
213 llvm::Expected<InputsAndPreamble> IP) {
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000214 if (!IP)
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000215 return Callback(IP.takeError());
216
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000217 auto PreambleData = IP->Preamble;
218 auto &Command = IP->Inputs.CompileCommand;
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000219 Callback(make_tagged(
Sam McCalld1a7a372018-01-31 13:40:48 +0000220 clangd::signatureHelp(File, Command,
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000221 PreambleData ? &PreambleData->Preamble : nullptr,
222 Contents, Pos, TaggedFS.Value, PCHs),
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000223 TaggedFS.Tag));
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000224 };
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000225
Sam McCall091557d2018-02-23 07:54:17 +0000226 WorkScheduler.runWithPreamble("SignatureHelp", File,
227 Bind(Action, File.str(), std::move(Callback)));
Ilya Biryukovd9bdfe02017-10-06 11:54:17 +0000228}
229
Raoul Wols212bcf82017-12-12 20:25:06 +0000230llvm::Expected<tooling::Replacements>
231ClangdServer::formatRange(StringRef Code, PathRef File, Range Rng) {
Ilya Biryukovafb55542017-05-16 14:40:30 +0000232 size_t Begin = positionToOffset(Code, Rng.start);
233 size_t Len = positionToOffset(Code, Rng.end) - Begin;
234 return formatCode(Code, File, {tooling::Range(Begin, Len)});
235}
236
Raoul Wols212bcf82017-12-12 20:25:06 +0000237llvm::Expected<tooling::Replacements> ClangdServer::formatFile(StringRef Code,
238 PathRef File) {
Ilya Biryukovafb55542017-05-16 14:40:30 +0000239 // Format everything.
Ilya Biryukovafb55542017-05-16 14:40:30 +0000240 return formatCode(Code, File, {tooling::Range(0, Code.size())});
241}
242
Raoul Wols212bcf82017-12-12 20:25:06 +0000243llvm::Expected<tooling::Replacements>
244ClangdServer::formatOnType(StringRef Code, PathRef File, Position Pos) {
Ilya Biryukovafb55542017-05-16 14:40:30 +0000245 // Look for the previous opening brace from the character position and
246 // format starting from there.
Ilya Biryukovafb55542017-05-16 14:40:30 +0000247 size_t CursorPos = positionToOffset(Code, Pos);
248 size_t PreviousLBracePos = StringRef(Code).find_last_of('{', CursorPos);
249 if (PreviousLBracePos == StringRef::npos)
250 PreviousLBracePos = CursorPos;
Sam McCallb536a2a2017-12-19 12:23:48 +0000251 size_t Len = CursorPos - PreviousLBracePos;
Ilya Biryukovafb55542017-05-16 14:40:30 +0000252
253 return formatCode(Code, File, {tooling::Range(PreviousLBracePos, Len)});
254}
Ilya Biryukov38d79772017-05-16 09:38:59 +0000255
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000256void ClangdServer::rename(
257 PathRef File, Position Pos, llvm::StringRef NewName,
258 UniqueFunction<void(Expected<std::vector<tooling::Replacement>>)>
259 Callback) {
260 auto Action = [Pos](Path File, std::string NewName,
261 decltype(Callback) Callback,
262 Expected<InputsAndAST> InpAST) {
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000263 if (!InpAST)
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000264 return Callback(InpAST.takeError());
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000265 auto &AST = InpAST->AST;
266
267 RefactoringResultCollector ResultCollector;
268 const SourceManager &SourceMgr = AST.getASTContext().getSourceManager();
Haojian Wu345099c2017-11-09 11:30:04 +0000269 const FileEntry *FE =
270 SourceMgr.getFileEntryForID(SourceMgr.getMainFileID());
271 if (!FE)
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000272 return Callback(llvm::make_error<llvm::StringError>(
273 "rename called for non-added document",
274 llvm::errc::invalid_argument));
Haojian Wu345099c2017-11-09 11:30:04 +0000275 SourceLocation SourceLocationBeg =
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000276 clangd::getBeginningOfIdentifier(AST, Pos, FE);
Haojian Wu345099c2017-11-09 11:30:04 +0000277 tooling::RefactoringRuleContext Context(
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000278 AST.getASTContext().getSourceManager());
279 Context.setASTContext(AST.getASTContext());
Haojian Wu345099c2017-11-09 11:30:04 +0000280 auto Rename = clang::tooling::RenameOccurrences::initiate(
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000281 Context, SourceRange(SourceLocationBeg), NewName);
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000282 if (!Rename)
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000283 return Callback(Rename.takeError());
Haojian Wu345099c2017-11-09 11:30:04 +0000284
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000285 Rename->invoke(ResultCollector, Context);
286
287 assert(ResultCollector.Result.hasValue());
288 if (!ResultCollector.Result.getValue())
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000289 return Callback(ResultCollector.Result->takeError());
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000290
291 std::vector<tooling::Replacement> Replacements;
292 for (const tooling::AtomicChange &Change : ResultCollector.Result->get()) {
293 tooling::Replacements ChangeReps = Change.getReplacements();
294 for (const auto &Rep : ChangeReps) {
295 // FIXME: Right now we only support renaming the main file, so we
296 // drop replacements not for the main file. In the future, we might
297 // consider to support:
298 // * rename in any included header
299 // * rename only in the "main" header
300 // * provide an error if there are symbols we won't rename (e.g.
301 // std::vector)
302 // * rename globally in project
303 // * rename in open files
304 if (Rep.getFilePath() == File)
305 Replacements.push_back(Rep);
306 }
Haojian Wu345099c2017-11-09 11:30:04 +0000307 }
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000308 return Callback(Replacements);
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000309 };
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000310
311 WorkScheduler.runWithAST(
Sam McCallc901c5d2018-02-19 09:56:28 +0000312 "Rename", File,
Sam McCall091557d2018-02-23 07:54:17 +0000313 Bind(Action, File.str(), NewName.str(), std::move(Callback)));
Haojian Wu345099c2017-11-09 11:30:04 +0000314}
315
Eric Liu6c8e8582018-02-26 08:32:13 +0000316/// Creates a `HeaderFile` from \p Header which can be either a URI or a literal
317/// include.
318static llvm::Expected<HeaderFile> toHeaderFile(StringRef Header,
319 llvm::StringRef HintPath) {
320 if (isLiteralInclude(Header))
321 return HeaderFile{Header.str(), /*Verbatim=*/true};
322 auto U = URI::parse(Header);
323 if (!U)
324 return U.takeError();
325 auto Resolved = URI::resolve(*U, HintPath);
326 if (!Resolved)
327 return Resolved.takeError();
328 return HeaderFile{std::move(*Resolved), /*Verbatim=*/false};
329};
330
Eric Liuc5105f92018-02-16 14:15:55 +0000331Expected<tooling::Replacements>
332ClangdServer::insertInclude(PathRef File, StringRef Code,
Eric Liu6c8e8582018-02-26 08:32:13 +0000333 StringRef DeclaringHeader,
334 StringRef InsertedHeader) {
335 assert(!DeclaringHeader.empty() && !InsertedHeader.empty());
Eric Liuc5105f92018-02-16 14:15:55 +0000336 std::string ToInclude;
Eric Liu6c8e8582018-02-26 08:32:13 +0000337 auto ResolvedOrginal = toHeaderFile(DeclaringHeader, File);
338 if (!ResolvedOrginal)
339 return ResolvedOrginal.takeError();
340 auto ResolvedPreferred = toHeaderFile(InsertedHeader, File);
341 if (!ResolvedPreferred)
342 return ResolvedPreferred.takeError();
343 tooling::CompileCommand CompileCommand = CompileArgs.getCompileCommand(File);
344 auto Include = calculateIncludePath(
345 File, Code, *ResolvedOrginal, *ResolvedPreferred, CompileCommand,
346 FSProvider.getTaggedFileSystem(File).Value);
347 if (!Include)
348 return Include.takeError();
349 if (Include->empty())
350 return tooling::Replacements();
351 ToInclude = std::move(*Include);
Eric Liuc5105f92018-02-16 14:15:55 +0000352
353 auto Style = format::getStyle("file", File, "llvm");
354 if (!Style) {
355 llvm::consumeError(Style.takeError());
356 // FIXME(ioeric): needs more consistent style support in clangd server.
357 Style = format::getLLVMStyle();
358 }
359 // Replacement with offset UINT_MAX and length 0 will be treated as include
360 // insertion.
361 tooling::Replacement R(File, /*Offset=*/UINT_MAX, 0, "#include " + ToInclude);
362 return format::cleanupAroundReplacements(Code, tooling::Replacements(R),
363 *Style);
364}
365
Ilya Biryukov261c72e2018-01-17 12:30:24 +0000366llvm::Optional<std::string> ClangdServer::getDocument(PathRef File) {
367 auto Latest = DraftMgr.getDraft(File);
368 if (!Latest.Draft)
369 return llvm::None;
370 return std::move(*Latest.Draft);
Ilya Biryukov38d79772017-05-16 09:38:59 +0000371}
372
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000373void ClangdServer::dumpAST(PathRef File,
374 UniqueFunction<void(std::string)> Callback) {
375 auto Action = [](decltype(Callback) Callback,
376 llvm::Expected<InputsAndAST> InpAST) {
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000377 if (!InpAST) {
378 ignoreError(InpAST.takeError());
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000379 return Callback("<no-ast>");
Ilya Biryukov02d58702017-08-01 15:51:38 +0000380 }
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000381 std::string Result;
382
383 llvm::raw_string_ostream ResultOS(Result);
384 clangd::dumpAST(InpAST->AST, ResultOS);
Ilya Biryukov02d58702017-08-01 15:51:38 +0000385 ResultOS.flush();
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000386
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000387 Callback(Result);
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000388 };
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000389
Sam McCall091557d2018-02-23 07:54:17 +0000390 WorkScheduler.runWithAST("DumpAST", File, Bind(Action, std::move(Callback)));
Ilya Biryukov38d79772017-05-16 09:38:59 +0000391}
Marc-Andre Laperle2cbf0372017-06-28 16:12:10 +0000392
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000393void ClangdServer::findDefinitions(
394 PathRef File, Position Pos,
395 UniqueFunction<void(llvm::Expected<Tagged<std::vector<Location>>>)>
396 Callback) {
Ilya Biryukov02d58702017-08-01 15:51:38 +0000397 auto TaggedFS = FSProvider.getTaggedFileSystem(File);
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000398 auto Action = [Pos, TaggedFS](decltype(Callback) Callback,
399 llvm::Expected<InputsAndAST> InpAST) {
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000400 if (!InpAST)
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000401 return Callback(InpAST.takeError());
Sam McCalld1a7a372018-01-31 13:40:48 +0000402 auto Result = clangd::findDefinitions(InpAST->AST, Pos);
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000403 Callback(make_tagged(std::move(Result), TaggedFS.Tag));
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000404 };
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000405
Sam McCallc901c5d2018-02-19 09:56:28 +0000406 WorkScheduler.runWithAST("Definitions", File,
Sam McCall091557d2018-02-23 07:54:17 +0000407 Bind(Action, std::move(Callback)));
Marc-Andre Laperle2cbf0372017-06-28 16:12:10 +0000408}
Ilya Biryukovc5ad35f2017-08-14 08:17:24 +0000409
Marc-Andre Laperle6571b3e2017-09-28 03:14:40 +0000410llvm::Optional<Path> ClangdServer::switchSourceHeader(PathRef Path) {
411
412 StringRef SourceExtensions[] = {".cpp", ".c", ".cc", ".cxx",
413 ".c++", ".m", ".mm"};
414 StringRef HeaderExtensions[] = {".h", ".hh", ".hpp", ".hxx", ".inc"};
415
416 StringRef PathExt = llvm::sys::path::extension(Path);
417
418 // Lookup in a list of known extensions.
419 auto SourceIter =
420 std::find_if(std::begin(SourceExtensions), std::end(SourceExtensions),
421 [&PathExt](PathRef SourceExt) {
422 return SourceExt.equals_lower(PathExt);
423 });
424 bool IsSource = SourceIter != std::end(SourceExtensions);
425
426 auto HeaderIter =
427 std::find_if(std::begin(HeaderExtensions), std::end(HeaderExtensions),
428 [&PathExt](PathRef HeaderExt) {
429 return HeaderExt.equals_lower(PathExt);
430 });
431
432 bool IsHeader = HeaderIter != std::end(HeaderExtensions);
433
434 // We can only switch between extensions known extensions.
435 if (!IsSource && !IsHeader)
436 return llvm::None;
437
438 // Array to lookup extensions for the switch. An opposite of where original
439 // extension was found.
440 ArrayRef<StringRef> NewExts;
441 if (IsSource)
442 NewExts = HeaderExtensions;
443 else
444 NewExts = SourceExtensions;
445
446 // Storage for the new path.
447 SmallString<128> NewPath = StringRef(Path);
448
449 // Instance of vfs::FileSystem, used for file existence checks.
450 auto FS = FSProvider.getTaggedFileSystem(Path).Value;
451
452 // Loop through switched extension candidates.
453 for (StringRef NewExt : NewExts) {
454 llvm::sys::path::replace_extension(NewPath, NewExt);
455 if (FS->exists(NewPath))
456 return NewPath.str().str(); // First str() to convert from SmallString to
457 // StringRef, second to convert from StringRef
458 // to std::string
Ilya Biryukov33334942017-10-06 14:39:39 +0000459
Marc-Andre Laperle6571b3e2017-09-28 03:14:40 +0000460 // Also check NewExt in upper-case, just in case.
461 llvm::sys::path::replace_extension(NewPath, NewExt.upper());
462 if (FS->exists(NewPath))
463 return NewPath.str().str();
Marc-Andre Laperle6571b3e2017-09-28 03:14:40 +0000464 }
465
466 return llvm::None;
467}
468
Raoul Wols212bcf82017-12-12 20:25:06 +0000469llvm::Expected<tooling::Replacements>
470ClangdServer::formatCode(llvm::StringRef Code, PathRef File,
471 ArrayRef<tooling::Range> Ranges) {
472 // Call clang-format.
473 auto TaggedFS = FSProvider.getTaggedFileSystem(File);
474 auto StyleOrError =
475 format::getStyle("file", File, "LLVM", Code, TaggedFS.Value.get());
476 if (!StyleOrError) {
477 return StyleOrError.takeError();
478 } else {
479 return format::reformat(StyleOrError.get(), Code, Ranges, File);
480 }
481}
482
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000483void ClangdServer::findDocumentHighlights(
484 PathRef File, Position Pos,
485 UniqueFunction<void(llvm::Expected<Tagged<std::vector<DocumentHighlight>>>)>
486 Callback) {
Ilya Biryukov0e6a51f2017-12-12 12:27:47 +0000487 auto FileContents = DraftMgr.getDraft(File);
488 if (!FileContents.Draft)
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000489 return Callback(llvm::make_error<llvm::StringError>(
Ilya Biryukov0e6a51f2017-12-12 12:27:47 +0000490 "findDocumentHighlights called on non-added file",
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000491 llvm::errc::invalid_argument));
Ilya Biryukov0e6a51f2017-12-12 12:27:47 +0000492
493 auto TaggedFS = FSProvider.getTaggedFileSystem(File);
494
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000495 auto Action = [TaggedFS, Pos](decltype(Callback) Callback,
496 llvm::Expected<InputsAndAST> InpAST) {
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000497 if (!InpAST)
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000498 return Callback(InpAST.takeError());
Sam McCalld1a7a372018-01-31 13:40:48 +0000499 auto Result = clangd::findDocumentHighlights(InpAST->AST, Pos);
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000500 Callback(make_tagged(std::move(Result), TaggedFS.Tag));
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000501 };
Ilya Biryukov2c5e8e82018-02-15 13:15:47 +0000502
Sam McCallc901c5d2018-02-19 09:56:28 +0000503 WorkScheduler.runWithAST("Highlights", File,
Sam McCall091557d2018-02-23 07:54:17 +0000504 Bind(Action, std::move(Callback)));
Ilya Biryukov0e6a51f2017-12-12 12:27:47 +0000505}
506
Marc-Andre Laperle3e618ed2018-02-16 21:38:15 +0000507void ClangdServer::findHover(
508 PathRef File, Position Pos,
509 UniqueFunction<void(llvm::Expected<Tagged<Hover>>)> Callback) {
510 Hover FinalHover;
511 auto FileContents = DraftMgr.getDraft(File);
512 if (!FileContents.Draft)
513 return Callback(llvm::make_error<llvm::StringError>(
514 "findHover called on non-added file", llvm::errc::invalid_argument));
515
516 auto TaggedFS = FSProvider.getTaggedFileSystem(File);
517
518 auto Action = [Pos, TaggedFS](decltype(Callback) Callback,
519 llvm::Expected<InputsAndAST> InpAST) {
520 if (!InpAST)
521 return Callback(InpAST.takeError());
522
523 Hover Result = clangd::getHover(InpAST->AST, Pos);
524 Callback(make_tagged(std::move(Result), TaggedFS.Tag));
525 };
526
Sam McCall091557d2018-02-23 07:54:17 +0000527 WorkScheduler.runWithAST("Hover", File, Bind(Action, std::move(Callback)));
Marc-Andre Laperle3e618ed2018-02-16 21:38:15 +0000528}
529
Sam McCall0bb24cd2018-02-13 08:59:23 +0000530void ClangdServer::scheduleReparseAndDiags(
Sam McCall568e17f2018-02-22 13:11:12 +0000531 PathRef File, VersionedDraft Contents, WantDiagnostics WantDiags,
Ilya Biryukov929697b2018-01-25 14:19:21 +0000532 Tagged<IntrusiveRefCntPtr<vfs::FileSystem>> TaggedFS) {
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000533 tooling::CompileCommand Command = CompileArgs.getCompileCommand(File);
Ilya Biryukov929697b2018-01-25 14:19:21 +0000534
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000535 DocVersion Version = Contents.Version;
536 Path FileStr = File.str();
537 VFSTag Tag = std::move(TaggedFS.Tag);
538
Sam McCall568e17f2018-02-22 13:11:12 +0000539 auto Callback = [this, Version, FileStr,
540 Tag](std::vector<DiagWithFixIts> Diags) {
Ilya Biryukov47f22022017-09-20 12:58:55 +0000541 // We need to serialize access to resulting diagnostics to avoid calling
542 // `onDiagnosticsReady` in the wrong order.
543 std::lock_guard<std::mutex> DiagsLock(DiagnosticsMutex);
544 DocVersion &LastReportedDiagsVersion = ReportedDiagnosticVersions[FileStr];
545 // FIXME(ibiryukov): get rid of '<' comparison here. In the current
546 // implementation diagnostics will not be reported after version counters'
547 // overflow. This should not happen in practice, since DocVersion is a
548 // 64-bit unsigned integer.
549 if (Version < LastReportedDiagsVersion)
550 return;
551 LastReportedDiagsVersion = Version;
552
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000553 DiagConsumer.onDiagnosticsReady(
Sam McCall568e17f2018-02-22 13:11:12 +0000554 FileStr, make_tagged(std::move(Diags), std::move(Tag)));
Ilya Biryukovc5ad35f2017-08-14 08:17:24 +0000555 };
556
Sam McCalld1a7a372018-01-31 13:40:48 +0000557 WorkScheduler.update(File,
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000558 ParseInputs{std::move(Command),
559 std::move(TaggedFS.Value),
560 std::move(*Contents.Draft)},
Sam McCall568e17f2018-02-22 13:11:12 +0000561 WantDiags, std::move(Callback));
Ilya Biryukovc5ad35f2017-08-14 08:17:24 +0000562}
Marc-Andre Laperlebf114242017-10-02 18:00:37 +0000563
Simon Marchi5178f922018-02-22 14:00:39 +0000564void ClangdServer::reparseOpenedFiles() {
565 for (const Path &FilePath : DraftMgr.getActiveFiles())
566 forceReparse(FilePath);
567}
568
Marc-Andre Laperlebf114242017-10-02 18:00:37 +0000569void ClangdServer::onFileEvent(const DidChangeWatchedFilesParams &Params) {
570 // FIXME: Do nothing for now. This will be used for indexing and potentially
571 // invalidating other caches.
572}
Ilya Biryukovdf842342018-01-25 14:32:21 +0000573
574std::vector<std::pair<Path, std::size_t>>
575ClangdServer::getUsedBytesPerFile() const {
Ilya Biryukov75f1dd92018-01-31 08:51:16 +0000576 return WorkScheduler.getUsedBytesPerFile();
Ilya Biryukovdf842342018-01-25 14:32:21 +0000577}
Sam McCall0bb24cd2018-02-13 08:59:23 +0000578
579LLVM_NODISCARD bool
580ClangdServer::blockUntilIdleForTest(llvm::Optional<double> TimeoutSeconds) {
581 return WorkScheduler.blockUntilIdle(timeoutSeconds(TimeoutSeconds));
582}