1 | //===--- ClangdServer.cpp - Main clangd server code --------------*- C++-*-===// |
2 | // |
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | // See https://llvm.org/LICENSE.txt for license information. |
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | // |
7 | //===-------------------------------------------------------------------===// |
8 | |
9 | #include "ClangdServer.h" |
10 | #include "CodeComplete.h" |
11 | #include "Config.h" |
12 | #include "Diagnostics.h" |
13 | #include "DumpAST.h" |
14 | #include "FindSymbols.h" |
15 | #include "Format.h" |
16 | #include "HeaderSourceSwitch.h" |
17 | #include "InlayHints.h" |
18 | #include "ParsedAST.h" |
19 | #include "Preamble.h" |
20 | #include "Protocol.h" |
21 | #include "SemanticHighlighting.h" |
22 | #include "SemanticSelection.h" |
23 | #include "SourceCode.h" |
24 | #include "TUScheduler.h" |
25 | #include "XRefs.h" |
26 | #include "clang-include-cleaner/Record.h" |
27 | #include "index/FileIndex.h" |
28 | #include "index/Merge.h" |
29 | #include "index/StdLib.h" |
30 | #include "refactor/Rename.h" |
31 | #include "refactor/Tweak.h" |
32 | #include "support/Cancellation.h" |
33 | #include "support/Logger.h" |
34 | #include "support/MemoryTree.h" |
35 | #include "support/ThreadsafeFS.h" |
36 | #include "support/Trace.h" |
37 | #include "clang/Basic/Stack.h" |
38 | #include "clang/Format/Format.h" |
39 | #include "clang/Lex/Preprocessor.h" |
40 | #include "clang/Tooling/CompilationDatabase.h" |
41 | #include "clang/Tooling/Core/Replacement.h" |
42 | #include "llvm/ADT/ArrayRef.h" |
43 | #include "llvm/ADT/STLExtras.h" |
44 | #include "llvm/ADT/StringRef.h" |
45 | #include "llvm/Support/Error.h" |
46 | #include "llvm/Support/Path.h" |
47 | #include "llvm/Support/raw_ostream.h" |
48 | #include <algorithm> |
49 | #include <chrono> |
50 | #include <future> |
51 | #include <memory> |
52 | #include <mutex> |
53 | #include <optional> |
54 | #include <string> |
55 | #include <type_traits> |
56 | #include <utility> |
57 | #include <vector> |
58 | |
59 | namespace clang { |
60 | namespace clangd { |
61 | namespace { |
62 | |
63 | // Tracks number of times a tweak has been offered. |
64 | static constexpr trace::Metric TweakAvailable( |
65 | "tweak_available" , trace::Metric::Counter, "tweak_id" ); |
66 | |
67 | // Update the FileIndex with new ASTs and plumb the diagnostics responses. |
68 | struct UpdateIndexCallbacks : public ParsingCallbacks { |
69 | UpdateIndexCallbacks(FileIndex *FIndex, |
70 | ClangdServer::Callbacks *ServerCallbacks, |
71 | const ThreadsafeFS &TFS, AsyncTaskRunner *Tasks, |
72 | bool CollectInactiveRegions) |
73 | : FIndex(FIndex), ServerCallbacks(ServerCallbacks), TFS(TFS), |
74 | Stdlib{std::make_shared<StdLibSet>()}, Tasks(Tasks), |
75 | CollectInactiveRegions(CollectInactiveRegions) {} |
76 | |
77 | void onPreambleAST( |
78 | PathRef Path, llvm::StringRef Version, CapturedASTCtx ASTCtx, |
79 | std::shared_ptr<const include_cleaner::PragmaIncludes> PI) override { |
80 | |
81 | if (!FIndex) |
82 | return; |
83 | |
84 | auto &PP = ASTCtx.getPreprocessor(); |
85 | auto &CI = ASTCtx.getCompilerInvocation(); |
86 | if (auto Loc = Stdlib->add(*CI.getLangOpts(), PP.getHeaderSearchInfo())) |
87 | indexStdlib(CI, std::move(*Loc)); |
88 | |
89 | // FIndex outlives the UpdateIndexCallbacks. |
90 | auto Task = [FIndex(FIndex), Path(Path.str()), Version(Version.str()), |
91 | ASTCtx(std::move(ASTCtx)), PI(std::move(PI))]() mutable { |
92 | trace::Span Tracer("PreambleIndexing" ); |
93 | FIndex->updatePreamble(Path, Version, ASTCtx.getASTContext(), |
94 | ASTCtx.getPreprocessor(), *PI); |
95 | }; |
96 | |
97 | if (Tasks) { |
98 | Tasks->runAsync("Preamble indexing for:" + Path + Version, |
99 | std::move(Task)); |
100 | } else |
101 | Task(); |
102 | } |
103 | |
104 | void indexStdlib(const CompilerInvocation &CI, StdLibLocation Loc) { |
105 | // This task is owned by Tasks, which outlives the TUScheduler and |
106 | // therefore the UpdateIndexCallbacks. |
107 | // We must be careful that the references we capture outlive TUScheduler. |
108 | auto Task = [LO(*CI.getLangOpts()), Loc(std::move(Loc)), |
109 | CI(std::make_unique<CompilerInvocation>(CI)), |
110 | // External values that outlive ClangdServer |
111 | TFS(&TFS), |
112 | // Index outlives TUScheduler (declared first) |
113 | FIndex(FIndex), |
114 | // shared_ptr extends lifetime |
115 | Stdlib(Stdlib)]() mutable { |
116 | clang::noteBottomOfStack(); |
117 | IndexFileIn IF; |
118 | IF.Symbols = indexStandardLibrary(std::move(CI), Loc, *TFS); |
119 | if (Stdlib->isBest(LO)) |
120 | FIndex->updatePreamble(std::move(IF)); |
121 | }; |
122 | if (Tasks) |
123 | // This doesn't have a semaphore to enforce -j, but it's rare. |
124 | Tasks->runAsync("IndexStdlib" , std::move(Task)); |
125 | else |
126 | Task(); |
127 | } |
128 | |
129 | void onMainAST(PathRef Path, ParsedAST &AST, PublishFn Publish) override { |
130 | if (FIndex) |
131 | FIndex->updateMain(Path, AST); |
132 | |
133 | if (ServerCallbacks) |
134 | Publish([&]() { |
135 | ServerCallbacks->onDiagnosticsReady(Path, AST.version(), |
136 | AST.getDiagnostics()); |
137 | if (CollectInactiveRegions) { |
138 | ServerCallbacks->onInactiveRegionsReady(Path, |
139 | getInactiveRegions(AST)); |
140 | } |
141 | }); |
142 | } |
143 | |
144 | void onFailedAST(PathRef Path, llvm::StringRef Version, |
145 | std::vector<Diag> Diags, PublishFn Publish) override { |
146 | if (ServerCallbacks) |
147 | Publish( |
148 | [&]() { ServerCallbacks->onDiagnosticsReady(Path, Version, Diags); }); |
149 | } |
150 | |
151 | void onFileUpdated(PathRef File, const TUStatus &Status) override { |
152 | if (ServerCallbacks) |
153 | ServerCallbacks->onFileUpdated(File, Status); |
154 | } |
155 | |
156 | void onPreamblePublished(PathRef File) override { |
157 | if (ServerCallbacks) |
158 | ServerCallbacks->onSemanticsMaybeChanged(File); |
159 | } |
160 | |
161 | private: |
162 | FileIndex *FIndex; |
163 | ClangdServer::Callbacks *ServerCallbacks; |
164 | const ThreadsafeFS &TFS; |
165 | std::shared_ptr<StdLibSet> Stdlib; |
166 | AsyncTaskRunner *Tasks; |
167 | bool CollectInactiveRegions; |
168 | }; |
169 | |
170 | class DraftStoreFS : public ThreadsafeFS { |
171 | public: |
172 | DraftStoreFS(const ThreadsafeFS &Base, const DraftStore &Drafts) |
173 | : Base(Base), DirtyFiles(Drafts) {} |
174 | |
175 | private: |
176 | llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> viewImpl() const override { |
177 | auto OFS = llvm::makeIntrusiveRefCnt<llvm::vfs::OverlayFileSystem>( |
178 | Base.view(std::nullopt)); |
179 | OFS->pushOverlay(DirtyFiles.asVFS()); |
180 | return OFS; |
181 | } |
182 | |
183 | const ThreadsafeFS &Base; |
184 | const DraftStore &DirtyFiles; |
185 | }; |
186 | |
187 | } // namespace |
188 | |
189 | ClangdServer::Options ClangdServer::optsForTest() { |
190 | ClangdServer::Options Opts; |
191 | Opts.UpdateDebounce = DebouncePolicy::fixed(/*zero*/ {}); |
192 | Opts.StorePreamblesInMemory = true; |
193 | Opts.AsyncThreadsCount = 4; // Consistent! |
194 | return Opts; |
195 | } |
196 | |
197 | ClangdServer::Options::operator TUScheduler::Options() const { |
198 | TUScheduler::Options Opts; |
199 | Opts.AsyncThreadsCount = AsyncThreadsCount; |
200 | Opts.RetentionPolicy = RetentionPolicy; |
201 | Opts.StorePreamblesInMemory = StorePreamblesInMemory; |
202 | Opts.UpdateDebounce = UpdateDebounce; |
203 | Opts.ContextProvider = ContextProvider; |
204 | Opts.PreambleThrottler = PreambleThrottler; |
205 | return Opts; |
206 | } |
207 | |
208 | ClangdServer::ClangdServer(const GlobalCompilationDatabase &CDB, |
209 | const ThreadsafeFS &TFS, const Options &Opts, |
210 | Callbacks *Callbacks) |
211 | : FeatureModules(Opts.FeatureModules), CDB(CDB), TFS(TFS), |
212 | DynamicIdx(Opts.BuildDynamicSymbolIndex ? new FileIndex() : nullptr), |
213 | ClangTidyProvider(Opts.ClangTidyProvider), |
214 | UseDirtyHeaders(Opts.UseDirtyHeaders), |
215 | LineFoldingOnly(Opts.LineFoldingOnly), |
216 | PreambleParseForwardingFunctions(Opts.PreambleParseForwardingFunctions), |
217 | ImportInsertions(Opts.ImportInsertions), |
218 | PublishInactiveRegions(Opts.PublishInactiveRegions), |
219 | WorkspaceRoot(Opts.WorkspaceRoot), |
220 | Transient(Opts.ImplicitCancellation ? TUScheduler::InvalidateOnUpdate |
221 | : TUScheduler::NoInvalidation), |
222 | DirtyFS(std::make_unique<DraftStoreFS>(TFS, DraftMgr)) { |
223 | if (Opts.AsyncThreadsCount != 0) |
224 | IndexTasks.emplace(); |
225 | // Pass a callback into `WorkScheduler` to extract symbols from a newly |
226 | // parsed file and rebuild the file index synchronously each time an AST |
227 | // is parsed. |
228 | WorkScheduler.emplace(CDB, TUScheduler::Options(Opts), |
229 | std::make_unique<UpdateIndexCallbacks>( |
230 | DynamicIdx.get(), Callbacks, TFS, |
231 | IndexTasks ? &*IndexTasks : nullptr, |
232 | PublishInactiveRegions)); |
233 | // Adds an index to the stack, at higher priority than existing indexes. |
234 | auto AddIndex = [&](SymbolIndex *Idx) { |
235 | if (this->Index != nullptr) { |
236 | MergedIdx.push_back(std::make_unique<MergedIndex>(Idx, this->Index)); |
237 | this->Index = MergedIdx.back().get(); |
238 | } else { |
239 | this->Index = Idx; |
240 | } |
241 | }; |
242 | if (Opts.StaticIndex) |
243 | AddIndex(Opts.StaticIndex); |
244 | if (Opts.BackgroundIndex) { |
245 | BackgroundIndex::Options BGOpts; |
246 | BGOpts.ThreadPoolSize = std::max(Opts.AsyncThreadsCount, 1u); |
247 | BGOpts.OnProgress = [Callbacks](BackgroundQueue::Stats S) { |
248 | if (Callbacks) |
249 | Callbacks->onBackgroundIndexProgress(S); |
250 | }; |
251 | BGOpts.ContextProvider = Opts.ContextProvider; |
252 | BackgroundIdx = std::make_unique<BackgroundIndex>( |
253 | TFS, CDB, |
254 | BackgroundIndexStorage::createDiskBackedStorageFactory( |
255 | [&CDB](llvm::StringRef File) { return CDB.getProjectInfo(File); }), |
256 | std::move(BGOpts)); |
257 | AddIndex(BackgroundIdx.get()); |
258 | } |
259 | if (DynamicIdx) |
260 | AddIndex(DynamicIdx.get()); |
261 | |
262 | if (Opts.FeatureModules) { |
263 | FeatureModule::Facilities F{ |
264 | *this->WorkScheduler, |
265 | this->Index, |
266 | this->TFS, |
267 | }; |
268 | for (auto &Mod : *Opts.FeatureModules) |
269 | Mod.initialize(F); |
270 | } |
271 | } |
272 | |
273 | ClangdServer::~ClangdServer() { |
274 | // Destroying TUScheduler first shuts down request threads that might |
275 | // otherwise access members concurrently. |
276 | // (Nobody can be using TUScheduler because we're on the main thread). |
277 | WorkScheduler.reset(); |
278 | // Now requests have stopped, we can shut down feature modules. |
279 | if (FeatureModules) { |
280 | for (auto &Mod : *FeatureModules) |
281 | Mod.stop(); |
282 | for (auto &Mod : *FeatureModules) |
283 | Mod.blockUntilIdle(Deadline::infinity()); |
284 | } |
285 | } |
286 | |
287 | void ClangdServer::addDocument(PathRef File, llvm::StringRef Contents, |
288 | llvm::StringRef Version, |
289 | WantDiagnostics WantDiags, bool ForceRebuild) { |
290 | std::string ActualVersion = DraftMgr.addDraft(File, Version, Contents); |
291 | ParseOptions Opts; |
292 | Opts.PreambleParseForwardingFunctions = PreambleParseForwardingFunctions; |
293 | Opts.ImportInsertions = ImportInsertions; |
294 | |
295 | // Compile command is set asynchronously during update, as it can be slow. |
296 | ParseInputs Inputs; |
297 | Inputs.TFS = &getHeaderFS(); |
298 | Inputs.Contents = std::string(Contents); |
299 | Inputs.Version = std::move(ActualVersion); |
300 | Inputs.ForceRebuild = ForceRebuild; |
301 | Inputs.Opts = std::move(Opts); |
302 | Inputs.Index = Index; |
303 | Inputs.ClangTidyProvider = ClangTidyProvider; |
304 | Inputs.FeatureModules = FeatureModules; |
305 | bool NewFile = WorkScheduler->update(File, Inputs, WantDiags); |
306 | // If we loaded Foo.h, we want to make sure Foo.cpp is indexed. |
307 | if (NewFile && BackgroundIdx) |
308 | BackgroundIdx->boostRelated(File); |
309 | } |
310 | |
311 | void ClangdServer::reparseOpenFilesIfNeeded( |
312 | llvm::function_ref<bool(llvm::StringRef File)> Filter) { |
313 | // Reparse only opened files that were modified. |
314 | for (const Path &FilePath : DraftMgr.getActiveFiles()) |
315 | if (Filter(FilePath)) |
316 | if (auto Draft = DraftMgr.getDraft(FilePath)) // else disappeared in race? |
317 | addDocument(FilePath, *Draft->Contents, Draft->Version, |
318 | WantDiagnostics::Auto); |
319 | } |
320 | |
321 | std::shared_ptr<const std::string> ClangdServer::getDraft(PathRef File) const { |
322 | auto Draft = DraftMgr.getDraft(File); |
323 | if (!Draft) |
324 | return nullptr; |
325 | return std::move(Draft->Contents); |
326 | } |
327 | |
328 | std::function<Context(PathRef)> |
329 | ClangdServer::createConfiguredContextProvider(const config::Provider *Provider, |
330 | Callbacks *Publish) { |
331 | if (!Provider) |
332 | return [](llvm::StringRef) { return Context::current().clone(); }; |
333 | |
334 | struct Impl { |
335 | const config::Provider *Provider; |
336 | ClangdServer::Callbacks *Publish; |
337 | std::mutex PublishMu; |
338 | |
339 | Impl(const config::Provider *Provider, ClangdServer::Callbacks *Publish) |
340 | : Provider(Provider), Publish(Publish) {} |
341 | |
342 | Context operator()(llvm::StringRef File) { |
343 | config::Params Params; |
344 | // Don't reread config files excessively often. |
345 | // FIXME: when we see a config file change event, use the event timestamp? |
346 | Params.FreshTime = |
347 | std::chrono::steady_clock::now() - std::chrono::seconds(5); |
348 | llvm::SmallString<256> PosixPath; |
349 | if (!File.empty()) { |
350 | assert(llvm::sys::path::is_absolute(File)); |
351 | llvm::sys::path::native(File, PosixPath, llvm::sys::path::Style::posix); |
352 | Params.Path = PosixPath.str(); |
353 | } |
354 | |
355 | llvm::StringMap<std::vector<Diag>> ReportableDiagnostics; |
356 | Config C = Provider->getConfig(Params, [&](const llvm::SMDiagnostic &D) { |
357 | // Create the map entry even for note diagnostics we don't report. |
358 | // This means that when the file is parsed with no warnings, we |
359 | // publish an empty set of diagnostics, clearing any the client has. |
360 | handleDiagnostic(D, !Publish || D.getFilename().empty() |
361 | ? nullptr |
362 | : &ReportableDiagnostics[D.getFilename()]); |
363 | }); |
364 | // Blindly publish diagnostics for the (unopened) parsed config files. |
365 | // We must avoid reporting diagnostics for *the same file* concurrently. |
366 | // Source diags are published elsewhere, but those are different files. |
367 | if (!ReportableDiagnostics.empty()) { |
368 | std::lock_guard<std::mutex> Lock(PublishMu); |
369 | for (auto &Entry : ReportableDiagnostics) |
370 | Publish->onDiagnosticsReady(Entry.first(), /*Version=*/"" , |
371 | Entry.second); |
372 | } |
373 | return Context::current().derive(Config::Key, std::move(C)); |
374 | } |
375 | |
376 | void handleDiagnostic(const llvm::SMDiagnostic &D, |
377 | std::vector<Diag> *ClientDiagnostics) { |
378 | switch (D.getKind()) { |
379 | case llvm::SourceMgr::DK_Error: |
380 | elog("config error at {0}:{1}:{2}: {3}" , D.getFilename(), D.getLineNo(), |
381 | D.getColumnNo(), D.getMessage()); |
382 | break; |
383 | case llvm::SourceMgr::DK_Warning: |
384 | log("config warning at {0}:{1}:{2}: {3}" , D.getFilename(), |
385 | D.getLineNo(), D.getColumnNo(), D.getMessage()); |
386 | break; |
387 | case llvm::SourceMgr::DK_Note: |
388 | case llvm::SourceMgr::DK_Remark: |
389 | vlog("config note at {0}:{1}:{2}: {3}" , D.getFilename(), D.getLineNo(), |
390 | D.getColumnNo(), D.getMessage()); |
391 | ClientDiagnostics = nullptr; // Don't emit notes as LSP diagnostics. |
392 | break; |
393 | } |
394 | if (ClientDiagnostics) |
395 | ClientDiagnostics->push_back(toDiag(D, Diag::ClangdConfig)); |
396 | } |
397 | }; |
398 | |
399 | // Copyable wrapper. |
400 | return [I(std::make_shared<Impl>(Provider, Publish))](llvm::StringRef Path) { |
401 | return (*I)(Path); |
402 | }; |
403 | } |
404 | |
405 | void ClangdServer::removeDocument(PathRef File) { |
406 | DraftMgr.removeDraft(File); |
407 | WorkScheduler->remove(File); |
408 | } |
409 | |
410 | void ClangdServer::codeComplete(PathRef File, Position Pos, |
411 | const clangd::CodeCompleteOptions &Opts, |
412 | Callback<CodeCompleteResult> CB) { |
413 | // Copy completion options for passing them to async task handler. |
414 | auto CodeCompleteOpts = Opts; |
415 | if (!CodeCompleteOpts.Index) // Respect overridden index. |
416 | CodeCompleteOpts.Index = Index; |
417 | |
418 | auto Task = [Pos, CodeCompleteOpts, File = File.str(), CB = std::move(CB), |
419 | this](llvm::Expected<InputsAndPreamble> IP) mutable { |
420 | if (!IP) |
421 | return CB(IP.takeError()); |
422 | if (auto Reason = isCancelled()) |
423 | return CB(llvm::make_error<CancelledError>(Reason)); |
424 | |
425 | std::optional<SpeculativeFuzzyFind> SpecFuzzyFind; |
426 | if (!IP->Preamble) { |
427 | // No speculation in Fallback mode, as it's supposed to be much faster |
428 | // without compiling. |
429 | vlog("Build for file {0} is not ready. Enter fallback mode." , File); |
430 | } else if (CodeCompleteOpts.Index) { |
431 | SpecFuzzyFind.emplace(); |
432 | { |
433 | std::lock_guard<std::mutex> Lock(CachedCompletionFuzzyFindRequestMutex); |
434 | SpecFuzzyFind->CachedReq = CachedCompletionFuzzyFindRequestByFile[File]; |
435 | } |
436 | } |
437 | ParseInputs ParseInput{IP->Command, &getHeaderFS(), IP->Contents.str()}; |
438 | // FIXME: Add traling new line if there is none at eof, workaround a crash, |
439 | // see https://github.com/clangd/clangd/issues/332 |
440 | if (!IP->Contents.endswith("\n" )) |
441 | ParseInput.Contents.append("\n" ); |
442 | ParseInput.Index = Index; |
443 | |
444 | CodeCompleteOpts.MainFileSignals = IP->Signals; |
445 | CodeCompleteOpts.AllScopes = Config::current().Completion.AllScopes; |
446 | // FIXME(ibiryukov): even if Preamble is non-null, we may want to check |
447 | // both the old and the new version in case only one of them matches. |
448 | CodeCompleteResult Result = clangd::codeComplete( |
449 | File, Pos, IP->Preamble, ParseInput, CodeCompleteOpts, |
450 | SpecFuzzyFind ? &*SpecFuzzyFind : nullptr); |
451 | { |
452 | clang::clangd::trace::Span Tracer("Completion results callback" ); |
453 | CB(std::move(Result)); |
454 | } |
455 | if (SpecFuzzyFind && SpecFuzzyFind->NewReq) { |
456 | std::lock_guard<std::mutex> Lock(CachedCompletionFuzzyFindRequestMutex); |
457 | CachedCompletionFuzzyFindRequestByFile[File] = *SpecFuzzyFind->NewReq; |
458 | } |
459 | // SpecFuzzyFind is only destroyed after speculative fuzzy find finishes. |
460 | // We don't want `codeComplete` to wait for the async call if it doesn't use |
461 | // the result (e.g. non-index completion, speculation fails), so that `CB` |
462 | // is called as soon as results are available. |
463 | }; |
464 | |
465 | // We use a potentially-stale preamble because latency is critical here. |
466 | WorkScheduler->runWithPreamble( |
467 | "CodeComplete" , File, |
468 | (Opts.RunParser == CodeCompleteOptions::AlwaysParse) |
469 | ? TUScheduler::Stale |
470 | : TUScheduler::StaleOrAbsent, |
471 | std::move(Task)); |
472 | } |
473 | |
474 | void ClangdServer::signatureHelp(PathRef File, Position Pos, |
475 | MarkupKind DocumentationFormat, |
476 | Callback<SignatureHelp> CB) { |
477 | |
478 | auto Action = [Pos, File = File.str(), CB = std::move(CB), |
479 | DocumentationFormat, |
480 | this](llvm::Expected<InputsAndPreamble> IP) mutable { |
481 | if (!IP) |
482 | return CB(IP.takeError()); |
483 | |
484 | const auto *PreambleData = IP->Preamble; |
485 | if (!PreambleData) |
486 | return CB(error("Failed to parse includes" )); |
487 | |
488 | ParseInputs ParseInput{IP->Command, &getHeaderFS(), IP->Contents.str()}; |
489 | // FIXME: Add traling new line if there is none at eof, workaround a crash, |
490 | // see https://github.com/clangd/clangd/issues/332 |
491 | if (!IP->Contents.endswith("\n" )) |
492 | ParseInput.Contents.append("\n" ); |
493 | ParseInput.Index = Index; |
494 | CB(clangd::signatureHelp(File, Pos, *PreambleData, ParseInput, |
495 | DocumentationFormat)); |
496 | }; |
497 | |
498 | // Unlike code completion, we wait for a preamble here. |
499 | WorkScheduler->runWithPreamble("SignatureHelp" , File, TUScheduler::Stale, |
500 | std::move(Action)); |
501 | } |
502 | |
503 | void ClangdServer::formatFile(PathRef File, std::optional<Range> Rng, |
504 | Callback<tooling::Replacements> CB) { |
505 | auto Code = getDraft(File); |
506 | if (!Code) |
507 | return CB(llvm::make_error<LSPError>("trying to format non-added document" , |
508 | ErrorCode::InvalidParams)); |
509 | tooling::Range RequestedRange; |
510 | if (Rng) { |
511 | llvm::Expected<size_t> Begin = positionToOffset(*Code, Rng->start); |
512 | if (!Begin) |
513 | return CB(Begin.takeError()); |
514 | llvm::Expected<size_t> End = positionToOffset(*Code, Rng->end); |
515 | if (!End) |
516 | return CB(End.takeError()); |
517 | RequestedRange = tooling::Range(*Begin, *End - *Begin); |
518 | } else { |
519 | RequestedRange = tooling::Range(0, Code->size()); |
520 | } |
521 | |
522 | // Call clang-format. |
523 | auto Action = [File = File.str(), Code = std::move(*Code), |
524 | Ranges = std::vector<tooling::Range>{RequestedRange}, |
525 | CB = std::move(CB), this]() mutable { |
526 | format::FormatStyle Style = getFormatStyleForFile(File, Code, TFS); |
527 | tooling::Replacements IncludeReplaces = |
528 | format::sortIncludes(Style, Code, Ranges, File); |
529 | auto Changed = tooling::applyAllReplacements(Code, IncludeReplaces); |
530 | if (!Changed) |
531 | return CB(Changed.takeError()); |
532 | |
533 | CB(IncludeReplaces.merge(format::reformat( |
534 | Style, *Changed, |
535 | tooling::calculateRangesAfterReplacements(IncludeReplaces, Ranges), |
536 | File))); |
537 | }; |
538 | WorkScheduler->runQuick("Format" , File, std::move(Action)); |
539 | } |
540 | |
541 | void ClangdServer::formatOnType(PathRef File, Position Pos, |
542 | StringRef TriggerText, |
543 | Callback<std::vector<TextEdit>> CB) { |
544 | auto Code = getDraft(File); |
545 | if (!Code) |
546 | return CB(llvm::make_error<LSPError>("trying to format non-added document" , |
547 | ErrorCode::InvalidParams)); |
548 | llvm::Expected<size_t> CursorPos = positionToOffset(*Code, Pos); |
549 | if (!CursorPos) |
550 | return CB(CursorPos.takeError()); |
551 | auto Action = [File = File.str(), Code = std::move(*Code), |
552 | TriggerText = TriggerText.str(), CursorPos = *CursorPos, |
553 | CB = std::move(CB), this]() mutable { |
554 | auto Style = format::getStyle(format::DefaultFormatStyle, File, |
555 | format::DefaultFallbackStyle, Code, |
556 | TFS.view(/*CWD=*/std::nullopt).get()); |
557 | if (!Style) |
558 | return CB(Style.takeError()); |
559 | |
560 | std::vector<TextEdit> Result; |
561 | for (const tooling::Replacement &R : |
562 | formatIncremental(Code, CursorPos, TriggerText, *Style)) |
563 | Result.push_back(replacementToEdit(Code, R)); |
564 | return CB(Result); |
565 | }; |
566 | WorkScheduler->runQuick("FormatOnType" , File, std::move(Action)); |
567 | } |
568 | |
569 | void ClangdServer::prepareRename(PathRef File, Position Pos, |
570 | std::optional<std::string> NewName, |
571 | const RenameOptions &RenameOpts, |
572 | Callback<RenameResult> CB) { |
573 | auto Action = [Pos, File = File.str(), CB = std::move(CB), |
574 | NewName = std::move(NewName), |
575 | RenameOpts](llvm::Expected<InputsAndAST> InpAST) mutable { |
576 | if (!InpAST) |
577 | return CB(InpAST.takeError()); |
578 | // prepareRename is latency-sensitive: we don't query the index, as we |
579 | // only need main-file references |
580 | auto Results = |
581 | clangd::rename({Pos, NewName.value_or("__clangd_rename_placeholder" ), |
582 | InpAST->AST, File, /*FS=*/nullptr, |
583 | /*Index=*/nullptr, RenameOpts}); |
584 | if (!Results) { |
585 | // LSP says to return null on failure, but that will result in a generic |
586 | // failure message. If we send an LSP error response, clients can surface |
587 | // the message to users (VSCode does). |
588 | return CB(Results.takeError()); |
589 | } |
590 | return CB(*Results); |
591 | }; |
592 | WorkScheduler->runWithAST("PrepareRename" , File, std::move(Action)); |
593 | } |
594 | |
595 | void ClangdServer::rename(PathRef File, Position Pos, llvm::StringRef NewName, |
596 | const RenameOptions &Opts, |
597 | Callback<RenameResult> CB) { |
598 | auto Action = [File = File.str(), NewName = NewName.str(), Pos, Opts, |
599 | CB = std::move(CB), |
600 | this](llvm::Expected<InputsAndAST> InpAST) mutable { |
601 | // Tracks number of files edited per invocation. |
602 | static constexpr trace::Metric RenameFiles("rename_files" , |
603 | trace::Metric::Distribution); |
604 | if (!InpAST) |
605 | return CB(InpAST.takeError()); |
606 | auto R = clangd::rename({Pos, NewName, InpAST->AST, File, |
607 | DirtyFS->view(std::nullopt), Index, Opts}); |
608 | if (!R) |
609 | return CB(R.takeError()); |
610 | |
611 | if (Opts.WantFormat) { |
612 | auto Style = getFormatStyleForFile(File, InpAST->Inputs.Contents, |
613 | *InpAST->Inputs.TFS); |
614 | llvm::Error Err = llvm::Error::success(); |
615 | for (auto &E : R->GlobalChanges) |
616 | Err = |
617 | llvm::joinErrors(reformatEdit(E.getValue(), Style), std::move(Err)); |
618 | |
619 | if (Err) |
620 | return CB(std::move(Err)); |
621 | } |
622 | RenameFiles.record(R->GlobalChanges.size()); |
623 | return CB(*R); |
624 | }; |
625 | WorkScheduler->runWithAST("Rename" , File, std::move(Action)); |
626 | } |
627 | |
628 | // May generate several candidate selections, due to SelectionTree ambiguity. |
629 | // vector of pointers because GCC doesn't like non-copyable Selection. |
630 | static llvm::Expected<std::vector<std::unique_ptr<Tweak::Selection>>> |
631 | tweakSelection(const Range &Sel, const InputsAndAST &AST, |
632 | llvm::vfs::FileSystem *FS) { |
633 | auto Begin = positionToOffset(AST.Inputs.Contents, Sel.start); |
634 | if (!Begin) |
635 | return Begin.takeError(); |
636 | auto End = positionToOffset(AST.Inputs.Contents, Sel.end); |
637 | if (!End) |
638 | return End.takeError(); |
639 | std::vector<std::unique_ptr<Tweak::Selection>> Result; |
640 | SelectionTree::createEach( |
641 | AST.AST.getASTContext(), AST.AST.getTokens(), *Begin, *End, |
642 | [&](SelectionTree T) { |
643 | Result.push_back(std::make_unique<Tweak::Selection>( |
644 | AST.Inputs.Index, AST.AST, *Begin, *End, std::move(T), FS)); |
645 | return false; |
646 | }); |
647 | assert(!Result.empty() && "Expected at least one SelectionTree" ); |
648 | return std::move(Result); |
649 | } |
650 | |
651 | void ClangdServer::codeAction(const CodeActionInputs &Params, |
652 | Callback<CodeActionResult> CB) { |
653 | auto Action = [Params, CB = std::move(CB), |
654 | FeatureModules(this->FeatureModules)]( |
655 | Expected<InputsAndAST> InpAST) mutable { |
656 | if (!InpAST) |
657 | return CB(InpAST.takeError()); |
658 | auto KindAllowed = |
659 | [Only(Params.RequestedActionKinds)](llvm::StringRef Kind) { |
660 | if (Only.empty()) |
661 | return true; |
662 | return llvm::any_of(Only, [&](llvm::StringRef Base) { |
663 | return Kind.consume_front(Base) && |
664 | (Kind.empty() || Kind.startswith("." )); |
665 | }); |
666 | }; |
667 | |
668 | CodeActionResult Result; |
669 | Result.Version = InpAST->AST.version().str(); |
670 | if (KindAllowed(CodeAction::QUICKFIX_KIND)) { |
671 | auto FindMatchedFixes = |
672 | [&InpAST](const DiagRef &DR) -> llvm::ArrayRef<Fix> { |
673 | for (const auto &Diag : InpAST->AST.getDiagnostics()) |
674 | if (Diag.Range == DR.Range && Diag.Message == DR.Message) |
675 | return Diag.Fixes; |
676 | return {}; |
677 | }; |
678 | for (const auto &Diag : Params.Diagnostics) |
679 | for (const auto &Fix : FindMatchedFixes(Diag)) |
680 | Result.QuickFixes.push_back({Diag, Fix}); |
681 | } |
682 | |
683 | // Collect Tweaks |
684 | auto Selections = tweakSelection(Params.Selection, *InpAST, /*FS=*/nullptr); |
685 | if (!Selections) |
686 | return CB(Selections.takeError()); |
687 | // Don't allow a tweak to fire more than once across ambiguous selections. |
688 | llvm::DenseSet<llvm::StringRef> PreparedTweaks; |
689 | auto DeduplicatingFilter = [&](const Tweak &T) { |
690 | return KindAllowed(T.kind()) && Params.TweakFilter(T) && |
691 | !PreparedTweaks.count(T.id()); |
692 | }; |
693 | for (const auto &Sel : *Selections) { |
694 | for (auto &T : prepareTweaks(*Sel, DeduplicatingFilter, FeatureModules)) { |
695 | Result.TweakRefs.push_back(TweakRef{T->id(), T->title(), T->kind()}); |
696 | PreparedTweaks.insert(T->id()); |
697 | TweakAvailable.record(1, T->id()); |
698 | } |
699 | } |
700 | CB(std::move(Result)); |
701 | }; |
702 | |
703 | WorkScheduler->runWithAST("codeAction" , Params.File, std::move(Action), |
704 | Transient); |
705 | } |
706 | |
707 | void ClangdServer::enumerateTweaks( |
708 | PathRef File, Range Sel, llvm::unique_function<bool(const Tweak &)> Filter, |
709 | Callback<std::vector<TweakRef>> CB) { |
710 | auto Action = [Sel, CB = std::move(CB), Filter = std::move(Filter), |
711 | FeatureModules(this->FeatureModules)]( |
712 | Expected<InputsAndAST> InpAST) mutable { |
713 | if (!InpAST) |
714 | return CB(InpAST.takeError()); |
715 | auto Selections = tweakSelection(Sel, *InpAST, /*FS=*/nullptr); |
716 | if (!Selections) |
717 | return CB(Selections.takeError()); |
718 | std::vector<TweakRef> Res; |
719 | // Don't allow a tweak to fire more than once across ambiguous selections. |
720 | llvm::DenseSet<llvm::StringRef> PreparedTweaks; |
721 | auto DeduplicatingFilter = [&](const Tweak &T) { |
722 | return Filter(T) && !PreparedTweaks.count(T.id()); |
723 | }; |
724 | for (const auto &Sel : *Selections) { |
725 | for (auto &T : prepareTweaks(*Sel, DeduplicatingFilter, FeatureModules)) { |
726 | Res.push_back({T->id(), T->title(), T->kind()}); |
727 | PreparedTweaks.insert(T->id()); |
728 | TweakAvailable.record(1, T->id()); |
729 | } |
730 | } |
731 | |
732 | CB(std::move(Res)); |
733 | }; |
734 | |
735 | WorkScheduler->runWithAST("EnumerateTweaks" , File, std::move(Action), |
736 | Transient); |
737 | } |
738 | |
739 | void ClangdServer::applyTweak(PathRef File, Range Sel, StringRef TweakID, |
740 | Callback<Tweak::Effect> CB) { |
741 | // Tracks number of times a tweak has been attempted. |
742 | static constexpr trace::Metric TweakAttempt( |
743 | "tweak_attempt" , trace::Metric::Counter, "tweak_id" ); |
744 | // Tracks number of times a tweak has failed to produce edits. |
745 | static constexpr trace::Metric TweakFailed( |
746 | "tweak_failed" , trace::Metric::Counter, "tweak_id" ); |
747 | TweakAttempt.record(1, TweakID); |
748 | auto Action = [File = File.str(), Sel, TweakID = TweakID.str(), |
749 | CB = std::move(CB), |
750 | this](Expected<InputsAndAST> InpAST) mutable { |
751 | if (!InpAST) |
752 | return CB(InpAST.takeError()); |
753 | auto FS = DirtyFS->view(std::nullopt); |
754 | auto Selections = tweakSelection(Sel, *InpAST, FS.get()); |
755 | if (!Selections) |
756 | return CB(Selections.takeError()); |
757 | std::optional<llvm::Expected<Tweak::Effect>> Effect; |
758 | // Try each selection, take the first one that prepare()s. |
759 | // If they all fail, Effect will hold get the last error. |
760 | for (const auto &Selection : *Selections) { |
761 | auto T = prepareTweak(TweakID, *Selection, FeatureModules); |
762 | if (T) { |
763 | Effect = (*T)->apply(*Selection); |
764 | break; |
765 | } |
766 | Effect = T.takeError(); |
767 | } |
768 | assert(Effect && "Expected at least one selection" ); |
769 | if (*Effect && (*Effect)->FormatEdits) { |
770 | // Format tweaks that require it centrally here. |
771 | for (auto &It : (*Effect)->ApplyEdits) { |
772 | Edit &E = It.second; |
773 | format::FormatStyle Style = |
774 | getFormatStyleForFile(File, E.InitialCode, TFS); |
775 | if (llvm::Error Err = reformatEdit(E, Style)) |
776 | elog("Failed to format {0}: {1}" , It.first(), std::move(Err)); |
777 | } |
778 | } else { |
779 | TweakFailed.record(1, TweakID); |
780 | } |
781 | return CB(std::move(*Effect)); |
782 | }; |
783 | WorkScheduler->runWithAST("ApplyTweak" , File, std::move(Action)); |
784 | } |
785 | |
786 | void ClangdServer::locateSymbolAt(PathRef File, Position Pos, |
787 | Callback<std::vector<LocatedSymbol>> CB) { |
788 | auto Action = [Pos, CB = std::move(CB), |
789 | this](llvm::Expected<InputsAndAST> InpAST) mutable { |
790 | if (!InpAST) |
791 | return CB(InpAST.takeError()); |
792 | CB(clangd::locateSymbolAt(InpAST->AST, Pos, Index)); |
793 | }; |
794 | |
795 | WorkScheduler->runWithAST("Definitions" , File, std::move(Action)); |
796 | } |
797 | |
798 | void ClangdServer::( |
799 | PathRef Path, Callback<std::optional<clangd::Path>> CB) { |
800 | // We want to return the result as fast as possible, strategy is: |
801 | // 1) use the file-only heuristic, it requires some IO but it is much |
802 | // faster than building AST, but it only works when .h/.cc files are in |
803 | // the same directory. |
804 | // 2) if 1) fails, we use the AST&Index approach, it is slower but supports |
805 | // different code layout. |
806 | if (auto CorrespondingFile = |
807 | getCorrespondingHeaderOrSource(Path, TFS.view(std::nullopt))) |
808 | return CB(std::move(CorrespondingFile)); |
809 | auto Action = [Path = Path.str(), CB = std::move(CB), |
810 | this](llvm::Expected<InputsAndAST> InpAST) mutable { |
811 | if (!InpAST) |
812 | return CB(InpAST.takeError()); |
813 | CB(getCorrespondingHeaderOrSource(Path, InpAST->AST, Index)); |
814 | }; |
815 | WorkScheduler->runWithAST("SwitchHeaderSource" , Path, std::move(Action)); |
816 | } |
817 | |
818 | void ClangdServer::findDocumentHighlights( |
819 | PathRef File, Position Pos, Callback<std::vector<DocumentHighlight>> CB) { |
820 | auto Action = |
821 | [Pos, CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable { |
822 | if (!InpAST) |
823 | return CB(InpAST.takeError()); |
824 | CB(clangd::findDocumentHighlights(InpAST->AST, Pos)); |
825 | }; |
826 | |
827 | WorkScheduler->runWithAST("Highlights" , File, std::move(Action), Transient); |
828 | } |
829 | |
830 | void ClangdServer::findHover(PathRef File, Position Pos, |
831 | Callback<std::optional<HoverInfo>> CB) { |
832 | auto Action = [File = File.str(), Pos, CB = std::move(CB), |
833 | this](llvm::Expected<InputsAndAST> InpAST) mutable { |
834 | if (!InpAST) |
835 | return CB(InpAST.takeError()); |
836 | format::FormatStyle Style = getFormatStyleForFile( |
837 | File, InpAST->Inputs.Contents, *InpAST->Inputs.TFS); |
838 | CB(clangd::getHover(InpAST->AST, Pos, std::move(Style), Index)); |
839 | }; |
840 | |
841 | WorkScheduler->runWithAST("Hover" , File, std::move(Action), Transient); |
842 | } |
843 | |
844 | void ClangdServer::typeHierarchy(PathRef File, Position Pos, int Resolve, |
845 | TypeHierarchyDirection Direction, |
846 | Callback<std::vector<TypeHierarchyItem>> CB) { |
847 | auto Action = [File = File.str(), Pos, Resolve, Direction, CB = std::move(CB), |
848 | this](Expected<InputsAndAST> InpAST) mutable { |
849 | if (!InpAST) |
850 | return CB(InpAST.takeError()); |
851 | CB(clangd::getTypeHierarchy(InpAST->AST, Pos, Resolve, Direction, Index, |
852 | File)); |
853 | }; |
854 | |
855 | WorkScheduler->runWithAST("TypeHierarchy" , File, std::move(Action)); |
856 | } |
857 | |
858 | void ClangdServer::superTypes( |
859 | const TypeHierarchyItem &Item, |
860 | Callback<std::optional<std::vector<TypeHierarchyItem>>> CB) { |
861 | WorkScheduler->run("typeHierarchy/superTypes" , /*Path=*/"" , |
862 | [=, CB = std::move(CB)]() mutable { |
863 | CB(clangd::superTypes(Item, Index)); |
864 | }); |
865 | } |
866 | |
867 | void ClangdServer::subTypes(const TypeHierarchyItem &Item, |
868 | Callback<std::vector<TypeHierarchyItem>> CB) { |
869 | WorkScheduler->run( |
870 | "typeHierarchy/subTypes" , /*Path=*/"" , |
871 | [=, CB = std::move(CB)]() mutable { CB(clangd::subTypes(Item, Index)); }); |
872 | } |
873 | |
874 | void ClangdServer::resolveTypeHierarchy( |
875 | TypeHierarchyItem Item, int Resolve, TypeHierarchyDirection Direction, |
876 | Callback<std::optional<TypeHierarchyItem>> CB) { |
877 | WorkScheduler->run( |
878 | "Resolve Type Hierarchy" , "" , [=, CB = std::move(CB)]() mutable { |
879 | clangd::resolveTypeHierarchy(Item, Resolve, Direction, Index); |
880 | CB(Item); |
881 | }); |
882 | } |
883 | |
884 | void ClangdServer::prepareCallHierarchy( |
885 | PathRef File, Position Pos, Callback<std::vector<CallHierarchyItem>> CB) { |
886 | auto Action = [File = File.str(), Pos, |
887 | CB = std::move(CB)](Expected<InputsAndAST> InpAST) mutable { |
888 | if (!InpAST) |
889 | return CB(InpAST.takeError()); |
890 | CB(clangd::prepareCallHierarchy(InpAST->AST, Pos, File)); |
891 | }; |
892 | WorkScheduler->runWithAST("CallHierarchy" , File, std::move(Action)); |
893 | } |
894 | |
895 | void ClangdServer::incomingCalls( |
896 | const CallHierarchyItem &Item, |
897 | Callback<std::vector<CallHierarchyIncomingCall>> CB) { |
898 | WorkScheduler->run("Incoming Calls" , "" , |
899 | [CB = std::move(CB), Item, this]() mutable { |
900 | CB(clangd::incomingCalls(Item, Index)); |
901 | }); |
902 | } |
903 | |
904 | void ClangdServer::inlayHints(PathRef File, std::optional<Range> RestrictRange, |
905 | Callback<std::vector<InlayHint>> CB) { |
906 | auto Action = [RestrictRange(std::move(RestrictRange)), |
907 | CB = std::move(CB)](Expected<InputsAndAST> InpAST) mutable { |
908 | if (!InpAST) |
909 | return CB(InpAST.takeError()); |
910 | CB(clangd::inlayHints(InpAST->AST, std::move(RestrictRange))); |
911 | }; |
912 | WorkScheduler->runWithAST("InlayHints" , File, std::move(Action), Transient); |
913 | } |
914 | |
915 | void ClangdServer::onFileEvent(const DidChangeWatchedFilesParams &Params) { |
916 | // FIXME: Do nothing for now. This will be used for indexing and potentially |
917 | // invalidating other caches. |
918 | } |
919 | |
920 | void ClangdServer::workspaceSymbols( |
921 | llvm::StringRef Query, int Limit, |
922 | Callback<std::vector<SymbolInformation>> CB) { |
923 | WorkScheduler->run( |
924 | "getWorkspaceSymbols" , /*Path=*/"" , |
925 | [Query = Query.str(), Limit, CB = std::move(CB), this]() mutable { |
926 | CB(clangd::getWorkspaceSymbols(Query, Limit, Index, |
927 | WorkspaceRoot.value_or("" ))); |
928 | }); |
929 | } |
930 | |
931 | void ClangdServer::documentSymbols(llvm::StringRef File, |
932 | Callback<std::vector<DocumentSymbol>> CB) { |
933 | auto Action = |
934 | [CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable { |
935 | if (!InpAST) |
936 | return CB(InpAST.takeError()); |
937 | CB(clangd::getDocumentSymbols(InpAST->AST)); |
938 | }; |
939 | WorkScheduler->runWithAST("DocumentSymbols" , File, std::move(Action), |
940 | Transient); |
941 | } |
942 | |
943 | void ClangdServer::foldingRanges(llvm::StringRef File, |
944 | Callback<std::vector<FoldingRange>> CB) { |
945 | auto Code = getDraft(File); |
946 | if (!Code) |
947 | return CB(llvm::make_error<LSPError>( |
948 | "trying to compute folding ranges for non-added document" , |
949 | ErrorCode::InvalidParams)); |
950 | auto Action = [LineFoldingOnly = LineFoldingOnly, CB = std::move(CB), |
951 | Code = std::move(*Code)]() mutable { |
952 | CB(clangd::getFoldingRanges(Code, LineFoldingOnly)); |
953 | }; |
954 | // We want to make sure folding ranges are always available for all the open |
955 | // files, hence prefer runQuick to not wait for operations on other files. |
956 | WorkScheduler->runQuick("FoldingRanges" , File, std::move(Action)); |
957 | } |
958 | |
959 | void ClangdServer::findType(llvm::StringRef File, Position Pos, |
960 | Callback<std::vector<LocatedSymbol>> CB) { |
961 | auto Action = [Pos, CB = std::move(CB), |
962 | this](llvm::Expected<InputsAndAST> InpAST) mutable { |
963 | if (!InpAST) |
964 | return CB(InpAST.takeError()); |
965 | CB(clangd::findType(InpAST->AST, Pos, Index)); |
966 | }; |
967 | WorkScheduler->runWithAST("FindType" , File, std::move(Action)); |
968 | } |
969 | |
970 | void ClangdServer::findImplementations( |
971 | PathRef File, Position Pos, Callback<std::vector<LocatedSymbol>> CB) { |
972 | auto Action = [Pos, CB = std::move(CB), |
973 | this](llvm::Expected<InputsAndAST> InpAST) mutable { |
974 | if (!InpAST) |
975 | return CB(InpAST.takeError()); |
976 | CB(clangd::findImplementations(InpAST->AST, Pos, Index)); |
977 | }; |
978 | |
979 | WorkScheduler->runWithAST("Implementations" , File, std::move(Action)); |
980 | } |
981 | |
982 | void ClangdServer::findReferences(PathRef File, Position Pos, uint32_t Limit, |
983 | bool AddContainer, |
984 | Callback<ReferencesResult> CB) { |
985 | auto Action = [Pos, Limit, AddContainer, CB = std::move(CB), |
986 | this](llvm::Expected<InputsAndAST> InpAST) mutable { |
987 | if (!InpAST) |
988 | return CB(InpAST.takeError()); |
989 | CB(clangd::findReferences(InpAST->AST, Pos, Limit, Index, AddContainer)); |
990 | }; |
991 | |
992 | WorkScheduler->runWithAST("References" , File, std::move(Action)); |
993 | } |
994 | |
995 | void ClangdServer::symbolInfo(PathRef File, Position Pos, |
996 | Callback<std::vector<SymbolDetails>> CB) { |
997 | auto Action = |
998 | [Pos, CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable { |
999 | if (!InpAST) |
1000 | return CB(InpAST.takeError()); |
1001 | CB(clangd::getSymbolInfo(InpAST->AST, Pos)); |
1002 | }; |
1003 | |
1004 | WorkScheduler->runWithAST("SymbolInfo" , File, std::move(Action)); |
1005 | } |
1006 | |
1007 | void ClangdServer::semanticRanges(PathRef File, |
1008 | const std::vector<Position> &Positions, |
1009 | Callback<std::vector<SelectionRange>> CB) { |
1010 | auto Action = [Positions, CB = std::move(CB)]( |
1011 | llvm::Expected<InputsAndAST> InpAST) mutable { |
1012 | if (!InpAST) |
1013 | return CB(InpAST.takeError()); |
1014 | std::vector<SelectionRange> Result; |
1015 | for (const auto &Pos : Positions) { |
1016 | if (auto Range = clangd::getSemanticRanges(InpAST->AST, Pos)) |
1017 | Result.push_back(std::move(*Range)); |
1018 | else |
1019 | return CB(Range.takeError()); |
1020 | } |
1021 | CB(std::move(Result)); |
1022 | }; |
1023 | WorkScheduler->runWithAST("SemanticRanges" , File, std::move(Action)); |
1024 | } |
1025 | |
1026 | void ClangdServer::documentLinks(PathRef File, |
1027 | Callback<std::vector<DocumentLink>> CB) { |
1028 | auto Action = |
1029 | [CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable { |
1030 | if (!InpAST) |
1031 | return CB(InpAST.takeError()); |
1032 | CB(clangd::getDocumentLinks(InpAST->AST)); |
1033 | }; |
1034 | WorkScheduler->runWithAST("DocumentLinks" , File, std::move(Action), |
1035 | Transient); |
1036 | } |
1037 | |
1038 | void ClangdServer::semanticHighlights( |
1039 | PathRef File, Callback<std::vector<HighlightingToken>> CB) { |
1040 | |
1041 | auto Action = [CB = std::move(CB), |
1042 | PublishInactiveRegions = PublishInactiveRegions]( |
1043 | llvm::Expected<InputsAndAST> InpAST) mutable { |
1044 | if (!InpAST) |
1045 | return CB(InpAST.takeError()); |
1046 | // Include inactive regions in semantic highlighting tokens only if the |
1047 | // client doesn't support a dedicated protocol for being informed about |
1048 | // them. |
1049 | CB(clangd::getSemanticHighlightings(InpAST->AST, !PublishInactiveRegions)); |
1050 | }; |
1051 | WorkScheduler->runWithAST("SemanticHighlights" , File, std::move(Action), |
1052 | Transient); |
1053 | } |
1054 | |
1055 | void ClangdServer::getAST(PathRef File, std::optional<Range> R, |
1056 | Callback<std::optional<ASTNode>> CB) { |
1057 | auto Action = |
1058 | [R, CB(std::move(CB))](llvm::Expected<InputsAndAST> Inputs) mutable { |
1059 | if (!Inputs) |
1060 | return CB(Inputs.takeError()); |
1061 | if (!R) { |
1062 | // It's safe to pass in the TU, as dumpAST() does not |
1063 | // deserialize the preamble. |
1064 | auto Node = DynTypedNode::create( |
1065 | *Inputs->AST.getASTContext().getTranslationUnitDecl()); |
1066 | return CB(dumpAST(Node, Inputs->AST.getTokens(), |
1067 | Inputs->AST.getASTContext())); |
1068 | } |
1069 | unsigned Start, End; |
1070 | if (auto Offset = positionToOffset(Inputs->Inputs.Contents, R->start)) |
1071 | Start = *Offset; |
1072 | else |
1073 | return CB(Offset.takeError()); |
1074 | if (auto Offset = positionToOffset(Inputs->Inputs.Contents, R->end)) |
1075 | End = *Offset; |
1076 | else |
1077 | return CB(Offset.takeError()); |
1078 | bool Success = SelectionTree::createEach( |
1079 | Inputs->AST.getASTContext(), Inputs->AST.getTokens(), Start, End, |
1080 | [&](SelectionTree T) { |
1081 | if (const SelectionTree::Node *N = T.commonAncestor()) { |
1082 | CB(dumpAST(N->ASTNode, Inputs->AST.getTokens(), |
1083 | Inputs->AST.getASTContext())); |
1084 | return true; |
1085 | } |
1086 | return false; |
1087 | }); |
1088 | if (!Success) |
1089 | CB(std::nullopt); |
1090 | }; |
1091 | WorkScheduler->runWithAST("GetAST" , File, std::move(Action)); |
1092 | } |
1093 | |
1094 | void ClangdServer::customAction(PathRef File, llvm::StringRef Name, |
1095 | Callback<InputsAndAST> Action) { |
1096 | WorkScheduler->runWithAST(Name, File, std::move(Action)); |
1097 | } |
1098 | |
1099 | void ClangdServer::diagnostics(PathRef File, Callback<std::vector<Diag>> CB) { |
1100 | auto Action = |
1101 | [CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable { |
1102 | if (!InpAST) |
1103 | return CB(InpAST.takeError()); |
1104 | return CB(InpAST->AST.getDiagnostics()); |
1105 | }; |
1106 | |
1107 | WorkScheduler->runWithAST("Diagnostics" , File, std::move(Action)); |
1108 | } |
1109 | |
1110 | llvm::StringMap<TUScheduler::FileStats> ClangdServer::fileStats() const { |
1111 | return WorkScheduler->fileStats(); |
1112 | } |
1113 | |
1114 | [[nodiscard]] bool |
1115 | ClangdServer::blockUntilIdleForTest(std::optional<double> TimeoutSeconds) { |
1116 | // Order is important here: we don't want to block on A and then B, |
1117 | // if B might schedule work on A. |
1118 | |
1119 | #if defined(__has_feature) && \ |
1120 | (__has_feature(address_sanitizer) || __has_feature(hwaddress_sanitizer) || \ |
1121 | __has_feature(memory_sanitizer) || __has_feature(thread_sanitizer)) |
1122 | (*TimeoutSeconds) *= 10; |
1123 | #endif |
1124 | |
1125 | // Nothing else can schedule work on TUScheduler, because it's not threadsafe |
1126 | // and we're blocking the main thread. |
1127 | if (!WorkScheduler->blockUntilIdle(timeoutSeconds(TimeoutSeconds))) |
1128 | return false; |
1129 | // TUScheduler is the only thing that starts background indexing work. |
1130 | if (IndexTasks && !IndexTasks->wait(timeoutSeconds(TimeoutSeconds))) |
1131 | return false; |
1132 | |
1133 | // Unfortunately we don't have strict topological order between the rest of |
1134 | // the components. E.g. CDB broadcast triggers backrgound indexing. |
1135 | // This queries the CDB which may discover new work if disk has changed. |
1136 | // |
1137 | // So try each one a few times in a loop. |
1138 | // If there are no tricky interactions then all after the first are no-ops. |
1139 | // Then on the last iteration, verify they're idle without waiting. |
1140 | // |
1141 | // There's a small chance they're juggling work and we didn't catch them :-( |
1142 | for (std::optional<double> Timeout : |
1143 | {TimeoutSeconds, TimeoutSeconds, std::optional<double>(0)}) { |
1144 | if (!CDB.blockUntilIdle(timeoutSeconds(Timeout))) |
1145 | return false; |
1146 | if (BackgroundIdx && !BackgroundIdx->blockUntilIdleForTest(Timeout)) |
1147 | return false; |
1148 | if (FeatureModules && llvm::any_of(*FeatureModules, [&](FeatureModule &M) { |
1149 | return !M.blockUntilIdle(timeoutSeconds(Timeout)); |
1150 | })) |
1151 | return false; |
1152 | } |
1153 | |
1154 | assert(WorkScheduler->blockUntilIdle(Deadline::zero()) && |
1155 | "Something scheduled work while we're blocking the main thread!" ); |
1156 | return true; |
1157 | } |
1158 | |
1159 | void ClangdServer::profile(MemoryTree &MT) const { |
1160 | if (DynamicIdx) |
1161 | DynamicIdx->profile(MT.child("dynamic_index" )); |
1162 | if (BackgroundIdx) |
1163 | BackgroundIdx->profile(MT.child("background_index" )); |
1164 | WorkScheduler->profile(MT.child("tuscheduler" )); |
1165 | } |
1166 | } // namespace clangd |
1167 | } // namespace clang |
1168 | |