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, Loc: 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, AST&: ASTCtx.getASTContext(), |
94 | PP&: ASTCtx.getPreprocessor(), PI: *PI); |
95 | }; |
96 | |
97 | if (Tasks) { |
98 | Tasks->runAsync(Name: "Preamble indexing for:" + Path + Version, |
99 | Action: 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>(args: 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(Invocation: std::move(CI), Loc, TFS: *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(Name: "IndexStdlib" , Action: 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(File: Path, Version: AST.version(), |
136 | Diagnostics: AST.getDiagnostics()); |
137 | if (CollectInactiveRegions) { |
138 | ServerCallbacks->onInactiveRegionsReady(File: Path, |
139 | InactiveRegions: 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(File: Path, Version, Diagnostics: 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 | A: Base.view(CWD: std::nullopt)); |
179 | OFS->pushOverlay(FS: 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>(args: TFS, args&: 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(args: CDB, args: TUScheduler::Options(Opts), |
229 | args: std::make_unique<UpdateIndexCallbacks>( |
230 | args: DynamicIdx.get(), args&: Callbacks, args: TFS, |
231 | args: IndexTasks ? &*IndexTasks : nullptr, |
232 | args&: 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(x: std::make_unique<MergedIndex>(args&: Idx, args&: 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(a: Opts.AsyncThreadsCount, b: 1u); |
247 | BGOpts.OnProgress = [Callbacks](BackgroundQueue::Stats S) { |
248 | if (Callbacks) |
249 | Callbacks->onBackgroundIndexProgress(Stats: S); |
250 | }; |
251 | BGOpts.ContextProvider = Opts.ContextProvider; |
252 | BackgroundIdx = std::make_unique<BackgroundIndex>( |
253 | args: TFS, args: CDB, |
254 | args: BackgroundIndexStorage::createDiskBackedStorageFactory( |
255 | GetProjectInfo: [&CDB](llvm::StringRef File) { return CDB.getProjectInfo(File); }), |
256 | args: 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 | .Scheduler: *this->WorkScheduler, |
265 | .Index: this->Index, |
266 | .FS: 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, WD: WantDiags); |
306 | // If we loaded Foo.h, we want to make sure Foo.cpp is indexed. |
307 | if (NewFile && BackgroundIdx) |
308 | BackgroundIdx->boostRelated(Path: 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(File: FilePath)) // else disappeared in race? |
317 | addDocument(File: FilePath, Contents: *Draft->Contents, Version: Draft->Version, |
318 | WantDiags: 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(path: File, result&: PosixPath, style: 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, ClientDiagnostics: !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(File: Entry.first(), /*Version=*/"" , |
371 | Diagnostics: Entry.second); |
372 | } |
373 | return Context::current().derive(Key: Config::Key, Value: 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(Fmt: "config error at {0}:{1}:{2}: {3}" , Vals: D.getFilename(), Vals: D.getLineNo(), |
381 | Vals: D.getColumnNo(), Vals: D.getMessage()); |
382 | break; |
383 | case llvm::SourceMgr::DK_Warning: |
384 | log(Fmt: "config warning at {0}:{1}:{2}: {3}" , Vals: D.getFilename(), |
385 | Vals: D.getLineNo(), Vals: D.getColumnNo(), Vals: D.getMessage()); |
386 | break; |
387 | case llvm::SourceMgr::DK_Note: |
388 | case llvm::SourceMgr::DK_Remark: |
389 | vlog(Fmt: "config note at {0}:{1}:{2}: {3}" , Vals: D.getFilename(), Vals: D.getLineNo(), |
390 | Vals: D.getColumnNo(), Vals: D.getMessage()); |
391 | ClientDiagnostics = nullptr; // Don't emit notes as LSP diagnostics. |
392 | break; |
393 | } |
394 | if (ClientDiagnostics) |
395 | ClientDiagnostics->push_back(x: toDiag(D, Source: Diag::ClangdConfig)); |
396 | } |
397 | }; |
398 | |
399 | // Copyable wrapper. |
400 | return [I(std::make_shared<Impl>(args&: Provider, args&: 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>(Args&: 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(Fmt: "Build for file {0} is not ready. Enter fallback mode." , Vals&: 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{.CompileCommand: IP->Command, .TFS: &getHeaderFS(), .Contents: 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.ends_with(Suffix: "\n" )) |
441 | ParseInput.Contents.append(s: "\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 | FileName: File, Pos, Preamble: IP->Preamble, ParseInput, Opts: CodeCompleteOpts, |
450 | SpecFuzzyFind: 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 | Name: "CodeComplete" , File, |
468 | Consistency: (Opts.RunParser == CodeCompleteOptions::AlwaysParse) |
469 | ? TUScheduler::Stale |
470 | : TUScheduler::StaleOrAbsent, |
471 | Action: 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(Fmt: "Failed to parse includes" )); |
487 | |
488 | ParseInputs ParseInput{.CompileCommand: IP->Command, .TFS: &getHeaderFS(), .Contents: 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.ends_with(Suffix: "\n" )) |
492 | ParseInput.Contents.append(s: "\n" ); |
493 | ParseInput.Index = Index; |
494 | CB(clangd::signatureHelp(FileName: File, Pos, Preamble: *PreambleData, ParseInput, |
495 | DocumentationFormat)); |
496 | }; |
497 | |
498 | // Unlike code completion, we wait for a preamble here. |
499 | WorkScheduler->runWithPreamble(Name: "SignatureHelp" , File, Consistency: TUScheduler::Stale, |
500 | Action: 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>(Args: "trying to format non-added document" , |
508 | Args: ErrorCode::InvalidParams)); |
509 | tooling::Range RequestedRange; |
510 | if (Rng) { |
511 | llvm::Expected<size_t> Begin = positionToOffset(Code: *Code, P: Rng->start); |
512 | if (!Begin) |
513 | return CB(Begin.takeError()); |
514 | llvm::Expected<size_t> End = positionToOffset(Code: *Code, P: 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, Content: Code, TFS); |
527 | tooling::Replacements IncludeReplaces = |
528 | format::sortIncludes(Style, Code, Ranges, FileName: File); |
529 | auto Changed = tooling::applyAllReplacements(Code, Replaces: IncludeReplaces); |
530 | if (!Changed) |
531 | return CB(Changed.takeError()); |
532 | |
533 | CB(IncludeReplaces.merge(Replaces: format::reformat( |
534 | Style, Code: *Changed, |
535 | Ranges: tooling::calculateRangesAfterReplacements(Replaces: IncludeReplaces, Ranges), |
536 | FileName: File))); |
537 | }; |
538 | WorkScheduler->runQuick(Name: "Format" , Path: File, Action: 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>(Args: "trying to format non-added document" , |
547 | Args: ErrorCode::InvalidParams)); |
548 | llvm::Expected<size_t> CursorPos = positionToOffset(Code: *Code, P: 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(StyleName: format::DefaultFormatStyle, FileName: File, |
555 | FallbackStyle: format::DefaultFallbackStyle, Code, |
556 | FS: 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, Cursor: CursorPos, InsertedText: TriggerText, Style: *Style)) |
563 | Result.push_back(x: replacementToEdit(Code, R)); |
564 | return CB(Result); |
565 | }; |
566 | WorkScheduler->runQuick(Name: "FormatOnType" , Path: File, Action: 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(RInputs: {.Pos: Pos, .NewName: NewName.value_or(u: "__clangd_rename_placeholder" ), |
582 | .AST: InpAST->AST, .MainFilePath: File, /*FS=*/nullptr, |
583 | /*Index=*/nullptr, .Opts: 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(Name: "PrepareRename" , File, Action: 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(RInputs: {.Pos: Pos, .NewName: NewName, .AST: InpAST->AST, .MainFilePath: File, |
607 | .FS: DirtyFS->view(CWD: std::nullopt), .Index: Index, .Opts: Opts}); |
608 | if (!R) |
609 | return CB(R.takeError()); |
610 | |
611 | if (Opts.WantFormat) { |
612 | auto Style = getFormatStyleForFile(File, Content: InpAST->Inputs.Contents, |
613 | TFS: *InpAST->Inputs.TFS); |
614 | llvm::Error Err = llvm::Error::success(); |
615 | for (auto &E : R->GlobalChanges) |
616 | Err = |
617 | llvm::joinErrors(E1: reformatEdit(E&: E.getValue(), Style), E2: std::move(Err)); |
618 | |
619 | if (Err) |
620 | return CB(std::move(Err)); |
621 | } |
622 | RenameFiles.record(Value: R->GlobalChanges.size()); |
623 | return CB(*R); |
624 | }; |
625 | WorkScheduler->runWithAST(Name: "Rename" , File, Action: 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(Code: AST.Inputs.Contents, P: Sel.start); |
634 | if (!Begin) |
635 | return Begin.takeError(); |
636 | auto End = positionToOffset(Code: AST.Inputs.Contents, P: Sel.end); |
637 | if (!End) |
638 | return End.takeError(); |
639 | std::vector<std::unique_ptr<Tweak::Selection>> Result; |
640 | SelectionTree::createEach( |
641 | AST&: AST.AST.getASTContext(), Tokens: AST.AST.getTokens(), Begin: *Begin, End: *End, |
642 | Func: [&](SelectionTree T) { |
643 | Result.push_back(x: std::make_unique<Tweak::Selection>( |
644 | args: AST.Inputs.Index, args&: AST.AST, args&: *Begin, args&: *End, args: std::move(T), args&: 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(Range: Only, P: [&](llvm::StringRef Base) { |
663 | return Kind.consume_front(Prefix: Base) && |
664 | (Kind.empty() || Kind.starts_with(Prefix: "." )); |
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(x: {.Diag: Diag, .F: Fix}); |
681 | } |
682 | |
683 | // Collect Tweaks |
684 | auto Selections = tweakSelection(Sel: Params.Selection, AST: *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(V: T.id()); |
692 | }; |
693 | for (const auto &Sel : *Selections) { |
694 | for (auto &T : prepareTweaks(S: *Sel, Filter: DeduplicatingFilter, Modules: FeatureModules)) { |
695 | Result.TweakRefs.push_back(x: TweakRef{.ID: T->id(), .Title: T->title(), .Kind: T->kind()}); |
696 | PreparedTweaks.insert(V: T->id()); |
697 | TweakAvailable.record(Value: 1, Label: T->id()); |
698 | } |
699 | } |
700 | CB(std::move(Result)); |
701 | }; |
702 | |
703 | WorkScheduler->runWithAST(Name: "codeAction" , File: Params.File, Action: std::move(Action), |
704 | Transient); |
705 | } |
706 | |
707 | void ClangdServer::applyTweak(PathRef File, Range Sel, StringRef TweakID, |
708 | Callback<Tweak::Effect> CB) { |
709 | // Tracks number of times a tweak has been attempted. |
710 | static constexpr trace::Metric TweakAttempt( |
711 | "tweak_attempt" , trace::Metric::Counter, "tweak_id" ); |
712 | // Tracks number of times a tweak has failed to produce edits. |
713 | static constexpr trace::Metric TweakFailed( |
714 | "tweak_failed" , trace::Metric::Counter, "tweak_id" ); |
715 | TweakAttempt.record(Value: 1, Label: TweakID); |
716 | auto Action = [File = File.str(), Sel, TweakID = TweakID.str(), |
717 | CB = std::move(CB), |
718 | this](Expected<InputsAndAST> InpAST) mutable { |
719 | if (!InpAST) |
720 | return CB(InpAST.takeError()); |
721 | auto FS = DirtyFS->view(CWD: std::nullopt); |
722 | auto Selections = tweakSelection(Sel, AST: *InpAST, FS: FS.get()); |
723 | if (!Selections) |
724 | return CB(Selections.takeError()); |
725 | std::optional<llvm::Expected<Tweak::Effect>> Effect; |
726 | // Try each selection, take the first one that prepare()s. |
727 | // If they all fail, Effect will hold get the last error. |
728 | for (const auto &Selection : *Selections) { |
729 | auto T = prepareTweak(ID: TweakID, S: *Selection, Modules: FeatureModules); |
730 | if (T) { |
731 | Effect = (*T)->apply(Sel: *Selection); |
732 | break; |
733 | } |
734 | Effect = T.takeError(); |
735 | } |
736 | assert(Effect && "Expected at least one selection" ); |
737 | if (*Effect && (*Effect)->FormatEdits) { |
738 | // Format tweaks that require it centrally here. |
739 | for (auto &It : (*Effect)->ApplyEdits) { |
740 | Edit &E = It.second; |
741 | format::FormatStyle Style = |
742 | getFormatStyleForFile(File, Content: E.InitialCode, TFS); |
743 | if (llvm::Error Err = reformatEdit(E, Style)) |
744 | elog(Fmt: "Failed to format {0}: {1}" , Vals: It.first(), Vals: std::move(Err)); |
745 | } |
746 | } else { |
747 | TweakFailed.record(Value: 1, Label: TweakID); |
748 | } |
749 | return CB(std::move(*Effect)); |
750 | }; |
751 | WorkScheduler->runWithAST(Name: "ApplyTweak" , File, Action: std::move(Action)); |
752 | } |
753 | |
754 | void ClangdServer::locateSymbolAt(PathRef File, Position Pos, |
755 | Callback<std::vector<LocatedSymbol>> CB) { |
756 | auto Action = [Pos, CB = std::move(CB), |
757 | this](llvm::Expected<InputsAndAST> InpAST) mutable { |
758 | if (!InpAST) |
759 | return CB(InpAST.takeError()); |
760 | CB(clangd::locateSymbolAt(AST&: InpAST->AST, Pos, Index)); |
761 | }; |
762 | |
763 | WorkScheduler->runWithAST(Name: "Definitions" , File, Action: std::move(Action)); |
764 | } |
765 | |
766 | void ClangdServer::( |
767 | PathRef Path, Callback<std::optional<clangd::Path>> CB) { |
768 | // We want to return the result as fast as possible, strategy is: |
769 | // 1) use the file-only heuristic, it requires some IO but it is much |
770 | // faster than building AST, but it only works when .h/.cc files are in |
771 | // the same directory. |
772 | // 2) if 1) fails, we use the AST&Index approach, it is slower but supports |
773 | // different code layout. |
774 | if (auto CorrespondingFile = |
775 | getCorrespondingHeaderOrSource(OriginalFile: Path, VFS: TFS.view(CWD: std::nullopt))) |
776 | return CB(std::move(CorrespondingFile)); |
777 | auto Action = [Path = Path.str(), CB = std::move(CB), |
778 | this](llvm::Expected<InputsAndAST> InpAST) mutable { |
779 | if (!InpAST) |
780 | return CB(InpAST.takeError()); |
781 | CB(getCorrespondingHeaderOrSource(OriginalFile: Path, AST&: InpAST->AST, Index)); |
782 | }; |
783 | WorkScheduler->runWithAST(Name: "SwitchHeaderSource" , File: Path, Action: std::move(Action)); |
784 | } |
785 | |
786 | void ClangdServer::findDocumentHighlights( |
787 | PathRef File, Position Pos, Callback<std::vector<DocumentHighlight>> CB) { |
788 | auto Action = |
789 | [Pos, CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable { |
790 | if (!InpAST) |
791 | return CB(InpAST.takeError()); |
792 | CB(clangd::findDocumentHighlights(AST&: InpAST->AST, Pos)); |
793 | }; |
794 | |
795 | WorkScheduler->runWithAST(Name: "Highlights" , File, Action: std::move(Action), Transient); |
796 | } |
797 | |
798 | void ClangdServer::findHover(PathRef File, Position Pos, |
799 | Callback<std::optional<HoverInfo>> CB) { |
800 | auto Action = [File = File.str(), Pos, CB = std::move(CB), |
801 | this](llvm::Expected<InputsAndAST> InpAST) mutable { |
802 | if (!InpAST) |
803 | return CB(InpAST.takeError()); |
804 | format::FormatStyle Style = getFormatStyleForFile( |
805 | File, Content: InpAST->Inputs.Contents, TFS: *InpAST->Inputs.TFS); |
806 | CB(clangd::getHover(AST&: InpAST->AST, Pos, Style: std::move(Style), Index)); |
807 | }; |
808 | |
809 | WorkScheduler->runWithAST(Name: "Hover" , File, Action: std::move(Action), Transient); |
810 | } |
811 | |
812 | void ClangdServer::typeHierarchy(PathRef File, Position Pos, int Resolve, |
813 | TypeHierarchyDirection Direction, |
814 | Callback<std::vector<TypeHierarchyItem>> CB) { |
815 | auto Action = [File = File.str(), Pos, Resolve, Direction, CB = std::move(CB), |
816 | this](Expected<InputsAndAST> InpAST) mutable { |
817 | if (!InpAST) |
818 | return CB(InpAST.takeError()); |
819 | CB(clangd::getTypeHierarchy(AST&: InpAST->AST, Pos, Resolve, Direction, Index, |
820 | TUPath: File)); |
821 | }; |
822 | |
823 | WorkScheduler->runWithAST(Name: "TypeHierarchy" , File, Action: std::move(Action)); |
824 | } |
825 | |
826 | void ClangdServer::superTypes( |
827 | const TypeHierarchyItem &Item, |
828 | Callback<std::optional<std::vector<TypeHierarchyItem>>> CB) { |
829 | WorkScheduler->run(Name: "typeHierarchy/superTypes" , /*Path=*/"" , |
830 | Action: [=, CB = std::move(CB)]() mutable { |
831 | CB(clangd::superTypes(Item, Index)); |
832 | }); |
833 | } |
834 | |
835 | void ClangdServer::subTypes(const TypeHierarchyItem &Item, |
836 | Callback<std::vector<TypeHierarchyItem>> CB) { |
837 | WorkScheduler->run( |
838 | Name: "typeHierarchy/subTypes" , /*Path=*/"" , |
839 | Action: [=, CB = std::move(CB)]() mutable { CB(clangd::subTypes(Item, Index)); }); |
840 | } |
841 | |
842 | void ClangdServer::resolveTypeHierarchy( |
843 | TypeHierarchyItem Item, int Resolve, TypeHierarchyDirection Direction, |
844 | Callback<std::optional<TypeHierarchyItem>> CB) { |
845 | WorkScheduler->run( |
846 | Name: "Resolve Type Hierarchy" , Path: "" , Action: [=, CB = std::move(CB)]() mutable { |
847 | clangd::resolveTypeHierarchy(Item, ResolveLevels: Resolve, Direction, Index); |
848 | CB(Item); |
849 | }); |
850 | } |
851 | |
852 | void ClangdServer::prepareCallHierarchy( |
853 | PathRef File, Position Pos, Callback<std::vector<CallHierarchyItem>> CB) { |
854 | auto Action = [File = File.str(), Pos, |
855 | CB = std::move(CB)](Expected<InputsAndAST> InpAST) mutable { |
856 | if (!InpAST) |
857 | return CB(InpAST.takeError()); |
858 | CB(clangd::prepareCallHierarchy(AST&: InpAST->AST, Pos, TUPath: File)); |
859 | }; |
860 | WorkScheduler->runWithAST(Name: "CallHierarchy" , File, Action: std::move(Action)); |
861 | } |
862 | |
863 | void ClangdServer::incomingCalls( |
864 | const CallHierarchyItem &Item, |
865 | Callback<std::vector<CallHierarchyIncomingCall>> CB) { |
866 | WorkScheduler->run(Name: "Incoming Calls" , Path: "" , |
867 | Action: [CB = std::move(CB), Item, this]() mutable { |
868 | CB(clangd::incomingCalls(Item, Index)); |
869 | }); |
870 | } |
871 | |
872 | void ClangdServer::inlayHints(PathRef File, std::optional<Range> RestrictRange, |
873 | Callback<std::vector<InlayHint>> CB) { |
874 | auto Action = [RestrictRange(std::move(RestrictRange)), |
875 | CB = std::move(CB)](Expected<InputsAndAST> InpAST) mutable { |
876 | if (!InpAST) |
877 | return CB(InpAST.takeError()); |
878 | CB(clangd::inlayHints(AST&: InpAST->AST, RestrictRange: std::move(RestrictRange))); |
879 | }; |
880 | WorkScheduler->runWithAST(Name: "InlayHints" , File, Action: std::move(Action), Transient); |
881 | } |
882 | |
883 | void ClangdServer::onFileEvent(const DidChangeWatchedFilesParams &Params) { |
884 | // FIXME: Do nothing for now. This will be used for indexing and potentially |
885 | // invalidating other caches. |
886 | } |
887 | |
888 | void ClangdServer::workspaceSymbols( |
889 | llvm::StringRef Query, int Limit, |
890 | Callback<std::vector<SymbolInformation>> CB) { |
891 | WorkScheduler->run( |
892 | Name: "getWorkspaceSymbols" , /*Path=*/"" , |
893 | Action: [Query = Query.str(), Limit, CB = std::move(CB), this]() mutable { |
894 | CB(clangd::getWorkspaceSymbols(Query, Limit, Index, |
895 | HintPath: WorkspaceRoot.value_or(u: "" ))); |
896 | }); |
897 | } |
898 | |
899 | void ClangdServer::documentSymbols(llvm::StringRef File, |
900 | Callback<std::vector<DocumentSymbol>> CB) { |
901 | auto Action = |
902 | [CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable { |
903 | if (!InpAST) |
904 | return CB(InpAST.takeError()); |
905 | CB(clangd::getDocumentSymbols(AST&: InpAST->AST)); |
906 | }; |
907 | WorkScheduler->runWithAST(Name: "DocumentSymbols" , File, Action: std::move(Action), |
908 | Transient); |
909 | } |
910 | |
911 | void ClangdServer::foldingRanges(llvm::StringRef File, |
912 | Callback<std::vector<FoldingRange>> CB) { |
913 | auto Code = getDraft(File); |
914 | if (!Code) |
915 | return CB(llvm::make_error<LSPError>( |
916 | Args: "trying to compute folding ranges for non-added document" , |
917 | Args: ErrorCode::InvalidParams)); |
918 | auto Action = [LineFoldingOnly = LineFoldingOnly, CB = std::move(CB), |
919 | Code = std::move(*Code)]() mutable { |
920 | CB(clangd::getFoldingRanges(Code, LineFoldingOnly)); |
921 | }; |
922 | // We want to make sure folding ranges are always available for all the open |
923 | // files, hence prefer runQuick to not wait for operations on other files. |
924 | WorkScheduler->runQuick(Name: "FoldingRanges" , Path: File, Action: std::move(Action)); |
925 | } |
926 | |
927 | void ClangdServer::findType(llvm::StringRef File, Position Pos, |
928 | Callback<std::vector<LocatedSymbol>> CB) { |
929 | auto Action = [Pos, CB = std::move(CB), |
930 | this](llvm::Expected<InputsAndAST> InpAST) mutable { |
931 | if (!InpAST) |
932 | return CB(InpAST.takeError()); |
933 | CB(clangd::findType(AST&: InpAST->AST, Pos, Index)); |
934 | }; |
935 | WorkScheduler->runWithAST(Name: "FindType" , File, Action: std::move(Action)); |
936 | } |
937 | |
938 | void ClangdServer::findImplementations( |
939 | PathRef File, Position Pos, Callback<std::vector<LocatedSymbol>> CB) { |
940 | auto Action = [Pos, CB = std::move(CB), |
941 | this](llvm::Expected<InputsAndAST> InpAST) mutable { |
942 | if (!InpAST) |
943 | return CB(InpAST.takeError()); |
944 | CB(clangd::findImplementations(AST&: InpAST->AST, Pos, Index)); |
945 | }; |
946 | |
947 | WorkScheduler->runWithAST(Name: "Implementations" , File, Action: std::move(Action)); |
948 | } |
949 | |
950 | void ClangdServer::findReferences(PathRef File, Position Pos, uint32_t Limit, |
951 | bool AddContainer, |
952 | Callback<ReferencesResult> CB) { |
953 | auto Action = [Pos, Limit, AddContainer, CB = std::move(CB), |
954 | this](llvm::Expected<InputsAndAST> InpAST) mutable { |
955 | if (!InpAST) |
956 | return CB(InpAST.takeError()); |
957 | CB(clangd::findReferences(AST&: InpAST->AST, Pos, Limit, Index, AddContext: AddContainer)); |
958 | }; |
959 | |
960 | WorkScheduler->runWithAST(Name: "References" , File, Action: std::move(Action)); |
961 | } |
962 | |
963 | void ClangdServer::symbolInfo(PathRef File, Position Pos, |
964 | Callback<std::vector<SymbolDetails>> CB) { |
965 | auto Action = |
966 | [Pos, CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable { |
967 | if (!InpAST) |
968 | return CB(InpAST.takeError()); |
969 | CB(clangd::getSymbolInfo(AST&: InpAST->AST, Pos)); |
970 | }; |
971 | |
972 | WorkScheduler->runWithAST(Name: "SymbolInfo" , File, Action: std::move(Action)); |
973 | } |
974 | |
975 | void ClangdServer::semanticRanges(PathRef File, |
976 | const std::vector<Position> &Positions, |
977 | Callback<std::vector<SelectionRange>> CB) { |
978 | auto Action = [Positions, CB = std::move(CB)]( |
979 | llvm::Expected<InputsAndAST> InpAST) mutable { |
980 | if (!InpAST) |
981 | return CB(InpAST.takeError()); |
982 | std::vector<SelectionRange> Result; |
983 | for (const auto &Pos : Positions) { |
984 | if (auto Range = clangd::getSemanticRanges(AST&: InpAST->AST, Pos)) |
985 | Result.push_back(x: std::move(*Range)); |
986 | else |
987 | return CB(Range.takeError()); |
988 | } |
989 | CB(std::move(Result)); |
990 | }; |
991 | WorkScheduler->runWithAST(Name: "SemanticRanges" , File, Action: std::move(Action)); |
992 | } |
993 | |
994 | void ClangdServer::documentLinks(PathRef File, |
995 | Callback<std::vector<DocumentLink>> CB) { |
996 | auto Action = |
997 | [CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable { |
998 | if (!InpAST) |
999 | return CB(InpAST.takeError()); |
1000 | CB(clangd::getDocumentLinks(AST&: InpAST->AST)); |
1001 | }; |
1002 | WorkScheduler->runWithAST(Name: "DocumentLinks" , File, Action: std::move(Action), |
1003 | Transient); |
1004 | } |
1005 | |
1006 | void ClangdServer::semanticHighlights( |
1007 | PathRef File, Callback<std::vector<HighlightingToken>> CB) { |
1008 | |
1009 | auto Action = [CB = std::move(CB), |
1010 | PublishInactiveRegions = PublishInactiveRegions]( |
1011 | llvm::Expected<InputsAndAST> InpAST) mutable { |
1012 | if (!InpAST) |
1013 | return CB(InpAST.takeError()); |
1014 | // Include inactive regions in semantic highlighting tokens only if the |
1015 | // client doesn't support a dedicated protocol for being informed about |
1016 | // them. |
1017 | CB(clangd::getSemanticHighlightings(AST&: InpAST->AST, IncludeInactiveRegionTokens: !PublishInactiveRegions)); |
1018 | }; |
1019 | WorkScheduler->runWithAST(Name: "SemanticHighlights" , File, Action: std::move(Action), |
1020 | Transient); |
1021 | } |
1022 | |
1023 | void ClangdServer::getAST(PathRef File, std::optional<Range> R, |
1024 | Callback<std::optional<ASTNode>> CB) { |
1025 | auto Action = |
1026 | [R, CB(std::move(CB))](llvm::Expected<InputsAndAST> Inputs) mutable { |
1027 | if (!Inputs) |
1028 | return CB(Inputs.takeError()); |
1029 | if (!R) { |
1030 | // It's safe to pass in the TU, as dumpAST() does not |
1031 | // deserialize the preamble. |
1032 | auto Node = DynTypedNode::create( |
1033 | Node: *Inputs->AST.getASTContext().getTranslationUnitDecl()); |
1034 | return CB(dumpAST(Node, Tokens: Inputs->AST.getTokens(), |
1035 | Inputs->AST.getASTContext())); |
1036 | } |
1037 | unsigned Start, End; |
1038 | if (auto Offset = positionToOffset(Code: Inputs->Inputs.Contents, P: R->start)) |
1039 | Start = *Offset; |
1040 | else |
1041 | return CB(Offset.takeError()); |
1042 | if (auto Offset = positionToOffset(Code: Inputs->Inputs.Contents, P: R->end)) |
1043 | End = *Offset; |
1044 | else |
1045 | return CB(Offset.takeError()); |
1046 | bool Success = SelectionTree::createEach( |
1047 | AST&: Inputs->AST.getASTContext(), Tokens: Inputs->AST.getTokens(), Begin: Start, End, |
1048 | Func: [&](SelectionTree T) { |
1049 | if (const SelectionTree::Node *N = T.commonAncestor()) { |
1050 | CB(dumpAST(N->ASTNode, Inputs->AST.getTokens(), |
1051 | Inputs->AST.getASTContext())); |
1052 | return true; |
1053 | } |
1054 | return false; |
1055 | }); |
1056 | if (!Success) |
1057 | CB(std::nullopt); |
1058 | }; |
1059 | WorkScheduler->runWithAST(Name: "GetAST" , File, Action: std::move(Action)); |
1060 | } |
1061 | |
1062 | void ClangdServer::customAction(PathRef File, llvm::StringRef Name, |
1063 | Callback<InputsAndAST> Action) { |
1064 | WorkScheduler->runWithAST(Name, File, Action: std::move(Action)); |
1065 | } |
1066 | |
1067 | void ClangdServer::diagnostics(PathRef File, Callback<std::vector<Diag>> CB) { |
1068 | auto Action = |
1069 | [CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable { |
1070 | if (!InpAST) |
1071 | return CB(InpAST.takeError()); |
1072 | return CB(InpAST->AST.getDiagnostics()); |
1073 | }; |
1074 | |
1075 | WorkScheduler->runWithAST(Name: "Diagnostics" , File, Action: std::move(Action)); |
1076 | } |
1077 | |
1078 | llvm::StringMap<TUScheduler::FileStats> ClangdServer::fileStats() const { |
1079 | return WorkScheduler->fileStats(); |
1080 | } |
1081 | |
1082 | [[nodiscard]] bool |
1083 | ClangdServer::blockUntilIdleForTest(std::optional<double> TimeoutSeconds) { |
1084 | // Order is important here: we don't want to block on A and then B, |
1085 | // if B might schedule work on A. |
1086 | |
1087 | #if defined(__has_feature) && \ |
1088 | (__has_feature(address_sanitizer) || __has_feature(hwaddress_sanitizer) || \ |
1089 | __has_feature(memory_sanitizer) || __has_feature(thread_sanitizer)) |
1090 | if (TimeoutSeconds.has_value()) |
1091 | (*TimeoutSeconds) *= 10; |
1092 | #endif |
1093 | |
1094 | // Nothing else can schedule work on TUScheduler, because it's not threadsafe |
1095 | // and we're blocking the main thread. |
1096 | if (!WorkScheduler->blockUntilIdle(D: timeoutSeconds(Seconds: TimeoutSeconds))) |
1097 | return false; |
1098 | // TUScheduler is the only thing that starts background indexing work. |
1099 | if (IndexTasks && !IndexTasks->wait(D: timeoutSeconds(Seconds: TimeoutSeconds))) |
1100 | return false; |
1101 | |
1102 | // Unfortunately we don't have strict topological order between the rest of |
1103 | // the components. E.g. CDB broadcast triggers backrgound indexing. |
1104 | // This queries the CDB which may discover new work if disk has changed. |
1105 | // |
1106 | // So try each one a few times in a loop. |
1107 | // If there are no tricky interactions then all after the first are no-ops. |
1108 | // Then on the last iteration, verify they're idle without waiting. |
1109 | // |
1110 | // There's a small chance they're juggling work and we didn't catch them :-( |
1111 | for (std::optional<double> Timeout : |
1112 | {TimeoutSeconds, TimeoutSeconds, std::optional<double>(0)}) { |
1113 | if (!CDB.blockUntilIdle(D: timeoutSeconds(Seconds: Timeout))) |
1114 | return false; |
1115 | if (BackgroundIdx && !BackgroundIdx->blockUntilIdleForTest(TimeoutSeconds: Timeout)) |
1116 | return false; |
1117 | if (FeatureModules && llvm::any_of(Range&: *FeatureModules, P: [&](FeatureModule &M) { |
1118 | return !M.blockUntilIdle(timeoutSeconds(Seconds: Timeout)); |
1119 | })) |
1120 | return false; |
1121 | } |
1122 | |
1123 | assert(WorkScheduler->blockUntilIdle(Deadline::zero()) && |
1124 | "Something scheduled work while we're blocking the main thread!" ); |
1125 | return true; |
1126 | } |
1127 | |
1128 | void ClangdServer::profile(MemoryTree &MT) const { |
1129 | if (DynamicIdx) |
1130 | DynamicIdx->profile(MT&: MT.child(Name: "dynamic_index" )); |
1131 | if (BackgroundIdx) |
1132 | BackgroundIdx->profile(MT&: MT.child(Name: "background_index" )); |
1133 | WorkScheduler->profile(MT&: MT.child(Name: "tuscheduler" )); |
1134 | } |
1135 | } // namespace clangd |
1136 | } // namespace clang |
1137 | |