26#include "clang-include-cleaner/Record.h"
38#include "clang/Basic/Stack.h"
39#include "clang/Format/Format.h"
40#include "clang/Lex/Preprocessor.h"
41#include "clang/Tooling/CompilationDatabase.h"
42#include "clang/Tooling/Core/Replacement.h"
43#include "llvm/ADT/ArrayRef.h"
44#include "llvm/ADT/STLExtras.h"
45#include "llvm/ADT/StringRef.h"
46#include "llvm/Support/Error.h"
47#include "llvm/Support/Path.h"
48#include "llvm/Support/raw_ostream.h"
65static constexpr trace::Metric TweakAvailable(
69struct UpdateIndexCallbacks :
public ParsingCallbacks {
70 UpdateIndexCallbacks(FileIndex *FIndex,
71 ClangdServer::Callbacks *ServerCallbacks,
72 const ThreadsafeFS &TFS, AsyncTaskRunner *Tasks,
73 bool CollectInactiveRegions)
74 : FIndex(FIndex), ServerCallbacks(ServerCallbacks), TFS(TFS),
75 Stdlib{std::make_shared<StdLibSet>()}, Tasks(Tasks),
76 CollectInactiveRegions(CollectInactiveRegions) {}
79 PathRef Path, llvm::StringRef Version, CapturedASTCtx ASTCtx,
80 std::shared_ptr<const include_cleaner::PragmaIncludes> PI)
override {
85 auto &PP = ASTCtx.getPreprocessor();
86 auto &
CI = ASTCtx.getCompilerInvocation();
87 if (
auto Loc = Stdlib->add(
CI.getLangOpts(), PP.getHeaderSearchInfo()))
88 indexStdlib(
CI, std::move(*
Loc));
91 auto Task = [FIndex(FIndex),
Path(
Path.str()), Version(Version.str()),
92 ASTCtx(std::move(ASTCtx)), PI(std::move(PI))]()
mutable {
93 trace::Span Tracer(
"PreambleIndexing");
94 FIndex->updatePreamble(
Path, Version, ASTCtx.getASTContext(),
95 ASTCtx.getPreprocessor(), *PI);
99 Tasks->runAsync(
"Preamble indexing for:" +
Path + Version,
105 void indexStdlib(
const CompilerInvocation &
CI, StdLibLocation
Loc) {
109 auto Task = [LO(
CI.getLangOpts()),
Loc(std::move(
Loc)),
110 CI(std::make_unique<CompilerInvocation>(
CI)),
121 WithContext
C(std::move(Ctx));
122 clang::noteBottomOfStack();
125 if (Stdlib->isBest(LO))
126 FIndex->updatePreamble(std::move(IF));
130 Tasks->runAsync(
"IndexStdlib", std::move(Task));
135 void onMainAST(
PathRef Path, ParsedAST &
AST, PublishFn Publish)
override {
141 ServerCallbacks->onDiagnosticsReady(
Path,
AST.version(),
142 AST.getDiagnostics());
143 if (CollectInactiveRegions) {
144 ServerCallbacks->onInactiveRegionsReady(
Path,
150 void onFailedAST(
PathRef Path, llvm::StringRef Version,
151 std::vector<Diag> Diags, PublishFn Publish)
override {
154 [&]() { ServerCallbacks->onDiagnosticsReady(
Path, Version, Diags); });
157 void onFileUpdated(
PathRef File,
const TUStatus &Status)
override {
159 ServerCallbacks->onFileUpdated(
File, Status);
164 ServerCallbacks->onSemanticsMaybeChanged(
File);
169 ClangdServer::Callbacks *ServerCallbacks;
170 const ThreadsafeFS &TFS;
171 std::shared_ptr<StdLibSet> Stdlib;
172 AsyncTaskRunner *Tasks;
173 bool CollectInactiveRegions;
176class DraftStoreFS :
public ThreadsafeFS {
178 DraftStoreFS(
const ThreadsafeFS &Base,
const DraftStore &Drafts)
179 : Base(Base), DirtyFiles(Drafts) {}
182 llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> viewImpl()
const override {
183 auto OFS = llvm::makeIntrusiveRefCnt<llvm::vfs::OverlayFileSystem>(
184 Base.view(std::nullopt));
185 OFS->pushOverlay(DirtyFiles.asVFS());
189 const ThreadsafeFS &Base;
190 const DraftStore &DirtyFiles;
198 Opts.StorePreamblesInMemory =
true;
199 Opts.AsyncThreadsCount = 4;
205 Opts.AsyncThreadsCount = AsyncThreadsCount;
206 Opts.RetentionPolicy = RetentionPolicy;
207 Opts.StorePreamblesInMemory = StorePreamblesInMemory;
208 Opts.UpdateDebounce = UpdateDebounce;
209 Opts.ContextProvider = ContextProvider;
218 DynamicIdx(Opts.BuildDynamicSymbolIndex ? new
FileIndex() : nullptr),
219 ClangTidyProvider(Opts.ClangTidyProvider),
220 UseDirtyHeaders(Opts.UseDirtyHeaders),
221 LineFoldingOnly(Opts.LineFoldingOnly),
222 PreambleParseForwardingFunctions(Opts.PreambleParseForwardingFunctions),
223 ImportInsertions(Opts.ImportInsertions),
224 PublishInactiveRegions(Opts.PublishInactiveRegions),
225 WorkspaceRoot(Opts.WorkspaceRoot),
226 Transient(Opts.ImplicitCancellation ?
TUScheduler::InvalidateOnUpdate
228 DirtyFS(std::make_unique<DraftStoreFS>(TFS, DraftMgr)) {
229 if (Opts.AsyncThreadsCount != 0)
230 IndexTasks.emplace();
235 std::make_unique<UpdateIndexCallbacks>(
237 IndexTasks ? &*IndexTasks :
nullptr,
238 PublishInactiveRegions));
241 if (this->Index !=
nullptr) {
242 MergedIdx.push_back(std::make_unique<MergedIndex>(Idx, this->Index));
243 this->Index = MergedIdx.back().get();
248 if (Opts.StaticIndex)
249 AddIndex(Opts.StaticIndex);
250 if (Opts.BackgroundIndex) {
258 BackgroundIdx = std::make_unique<BackgroundIndex>(
261 [&CDB](llvm::StringRef
File) {
return CDB.getProjectInfo(
File); }),
263 AddIndex(BackgroundIdx.get());
266 AddIndex(DynamicIdx.get());
268 if (Opts.FeatureModules) {
270 *this->WorkScheduler,
274 for (
auto &Mod : *Opts.FeatureModules)
283 WorkScheduler.reset();
285 if (FeatureModules) {
286 for (
auto &Mod : *FeatureModules)
294 llvm::StringRef Version,
296 std::string ActualVersion = DraftMgr.
addDraft(
File, Version, Contents);
298 Opts.PreambleParseForwardingFunctions = PreambleParseForwardingFunctions;
299 Opts.ImportInsertions = ImportInsertions;
303 Inputs.TFS = &getHeaderFS();
304 Inputs.Contents = std::string(Contents);
305 Inputs.Version = std::move(ActualVersion);
306 Inputs.ForceRebuild = ForceRebuild;
307 Inputs.Opts = std::move(Opts);
308 Inputs.Index = Index;
309 Inputs.ClangTidyProvider = ClangTidyProvider;
310 Inputs.FeatureModules = FeatureModules;
311 bool NewFile = WorkScheduler->update(
File, Inputs,
WantDiags);
313 if (NewFile && BackgroundIdx)
314 BackgroundIdx->boostRelated(
File);
318 llvm::function_ref<
bool(llvm::StringRef
File)> Filter) {
321 if (Filter(FilePath))
322 if (
auto Draft = DraftMgr.
getDraft(FilePath))
323 addDocument(FilePath, *Draft->Contents, Draft->Version,
331 return std::move(Draft->Contents);
343 std::mutex PublishMu;
346 : Provider(Provider), Publish(Publish) {}
348 Context operator()(llvm::StringRef File) {
353 std::chrono::steady_clock::now() - std::chrono::seconds(5);
354 llvm::SmallString<256> PosixPath;
356 assert(llvm::sys::path::is_absolute(File));
357 llvm::sys::path::native(File, PosixPath, llvm::sys::path::Style::posix);
358 Params.
Path = PosixPath.str();
361 llvm::StringMap<std::vector<Diag>> ReportableDiagnostics;
366 handleDiagnostic(D, !Publish || D.getFilename().empty()
368 : &ReportableDiagnostics[D.getFilename()]);
373 if (!ReportableDiagnostics.empty()) {
374 std::lock_guard<std::mutex> Lock(PublishMu);
375 for (
auto &
Entry : ReportableDiagnostics)
379 return Context::current().derive(Config::Key, std::move(
C));
382 void handleDiagnostic(
const llvm::SMDiagnostic &D,
383 std::vector<Diag> *ClientDiagnostics) {
384 switch (D.getKind()) {
385 case llvm::SourceMgr::DK_Error:
386 elog(
"config error at {0}:{1}:{2}: {3}", D.getFilename(), D.getLineNo(),
387 D.getColumnNo(), D.getMessage());
389 case llvm::SourceMgr::DK_Warning:
390 log(
"config warning at {0}:{1}:{2}: {3}", D.getFilename(),
391 D.getLineNo(), D.getColumnNo(), D.getMessage());
393 case llvm::SourceMgr::DK_Note:
394 case llvm::SourceMgr::DK_Remark:
395 vlog(
"config note at {0}:{1}:{2}: {3}", D.getFilename(), D.getLineNo(),
396 D.getColumnNo(), D.getMessage());
397 ClientDiagnostics =
nullptr;
400 if (ClientDiagnostics)
401 ClientDiagnostics->push_back(
toDiag(D, Diag::ClangdConfig));
406 return [I(std::make_shared<Impl>(Provider, Publish))](llvm::StringRef
Path) {
413 WorkScheduler->remove(
File);
420 auto CodeCompleteOpts = Opts;
421 if (!CodeCompleteOpts.Index)
422 CodeCompleteOpts.Index = Index;
424 auto Task = [
Pos, CodeCompleteOpts,
File =
File.str(), CB = std::move(CB),
425 this](llvm::Expected<InputsAndPreamble> IP)
mutable {
427 return CB(IP.takeError());
429 return CB(llvm::make_error<CancelledError>(Reason));
431 std::optional<SpeculativeFuzzyFind> SpecFuzzyFind;
435 vlog(
"Build for file {0} is not ready. Enter fallback mode.",
File);
436 }
else if (CodeCompleteOpts.Index) {
437 SpecFuzzyFind.emplace();
439 std::lock_guard<std::mutex> Lock(CachedCompletionFuzzyFindRequestMutex);
440 SpecFuzzyFind->CachedReq = CachedCompletionFuzzyFindRequestByFile[
File];
446 if (!IP->Contents.ends_with(
"\n"))
450 CodeCompleteOpts.MainFileSignals = IP->Signals;
456 SpecFuzzyFind ? &*SpecFuzzyFind :
nullptr);
459 CB(std::move(Result));
461 if (SpecFuzzyFind && SpecFuzzyFind->NewReq) {
462 std::lock_guard<std::mutex> Lock(CachedCompletionFuzzyFindRequestMutex);
463 CachedCompletionFuzzyFindRequestByFile[
File] = *SpecFuzzyFind->NewReq;
472 WorkScheduler->runWithPreamble(
473 "CodeComplete",
File,
486 this](llvm::Expected<InputsAndPreamble> IP)
mutable {
488 return CB(IP.takeError());
492 return CB(
error(
"Failed to parse includes"));
497 if (!IP->Contents.ends_with(
"\n"))
501 DocumentationFormat));
513 return CB(llvm::make_error<LSPError>(
"trying to format non-added document",
515 tooling::Range RequestedRange;
519 return CB(Begin.takeError());
522 return CB(End.takeError());
523 RequestedRange = tooling::Range(*Begin, *End - *Begin);
525 RequestedRange = tooling::Range(0,
Code->size());
530 Ranges = std::vector<tooling::Range>{RequestedRange},
531 CB = std::move(CB),
this]()
mutable {
533 tooling::Replacements IncludeReplaces =
534 format::sortIncludes(Style,
Code, Ranges,
File);
535 auto Changed = tooling::applyAllReplacements(
Code, IncludeReplaces);
537 return CB(
Changed.takeError());
539 CB(IncludeReplaces.merge(format::reformat(
541 tooling::calculateRangesAfterReplacements(IncludeReplaces, Ranges),
544 WorkScheduler->runQuick(
"Format",
File, std::move(
Action));
548 StringRef TriggerText,
549 Callback<std::vector<TextEdit>> CB) {
552 return CB(llvm::make_error<LSPError>(
"trying to format non-added document",
556 return CB(CursorPos.takeError());
558 TriggerText = TriggerText.str(), CursorPos = *CursorPos,
559 CB = std::move(CB),
this]()
mutable {
561 std::vector<TextEdit> Result;
562 for (
const tooling::Replacement &R :
567 WorkScheduler->runQuick(
"FormatOnType",
File, std::move(
Action));
571 std::optional<std::string> NewName,
575 NewName = std::move(NewName),
576 RenameOpts](llvm::Expected<InputsAndAST> InpAST)
mutable {
578 return CB(InpAST.takeError());
583 InpAST->AST,
File,
nullptr,
584 nullptr, RenameOpts});
589 return CB(
Results.takeError());
593 WorkScheduler->runWithAST(
"PrepareRename",
File, std::move(
Action));
601 this](llvm::Expected<InputsAndAST> InpAST)
mutable {
606 return CB(InpAST.takeError());
608 DirtyFS->view(std::nullopt), Index, Opts});
610 return CB(R.takeError());
612 if (Opts.WantFormat) {
614 *InpAST->Inputs.TFS,
false);
615 llvm::Error Err = llvm::Error::success();
616 for (
auto &
E : R->GlobalChanges)
618 llvm::joinErrors(
reformatEdit(
E.getValue(), Style), std::move(Err));
621 return CB(std::move(Err));
623 RenameFiles.
record(R->GlobalChanges.size());
626 WorkScheduler->runWithAST(
"Rename",
File, std::move(
Action));
632llvm::Expected<std::vector<std::unique_ptr<Tweak::Selection>>>
634 llvm::vfs::FileSystem *FS) {
637 return Begin.takeError();
640 return End.takeError();
641 std::vector<std::unique_ptr<Tweak::Selection>> Result;
643 AST.AST.getASTContext(),
AST.AST.getTokens(), *Begin, *End,
645 Result.push_back(std::make_unique<Tweak::Selection>(
646 AST.Inputs.Index, AST.AST, *Begin, *End, std::move(T), FS));
649 assert(!Result.empty() &&
"Expected at least one SelectionTree");
650 return std::move(Result);
656std::optional<ClangdServer::CodeActionResult::Rename>
657tryConvertToRename(
const Diag *Diag,
const Fix &Fix) {
659 Diag->Name ==
"readability-identifier-naming" &&
661 if (IsClangTidyRename && Diag->InsideMainFile) {
662 ClangdServer::CodeActionResult::Rename R;
663 R.NewName = Fix.Edits.front().newText;
664 R.FixMessage = Fix.Message;
665 R.Diag = {Diag->Range, Diag->Message};
676 auto Action = [Params, CB = std::move(CB),
677 FeatureModules(this->FeatureModules)](
678 Expected<InputsAndAST> InpAST)
mutable {
680 return CB(InpAST.takeError());
685 return llvm::any_of(Only, [&](llvm::StringRef Base) {
686 return Kind.consume_front(Base) &&
687 (
Kind.empty() ||
Kind.starts_with(
"."));
692 Result.Version = InpAST->AST.version().str();
694 auto FindMatchedDiag = [&InpAST](
const DiagRef &DR) ->
const Diag * {
695 for (
const auto &
Diag : InpAST->AST.getDiagnostics())
703 if (
auto Rename = tryConvertToRename(
Diag,
Fix)) {
704 Result.Renames.emplace_back(std::move(*Rename));
713 auto Selections = tweakSelection(Params.
Selection, *InpAST,
nullptr);
715 return CB(Selections.takeError());
717 llvm::DenseSet<llvm::StringRef> PreparedTweaks;
718 auto DeduplicatingFilter = [&](
const Tweak &T) {
719 return KindAllowed(T.kind()) && Params.
TweakFilter(T) &&
720 !PreparedTweaks.count(T.id());
722 for (
const auto &Sel : *Selections) {
723 for (
auto &T :
prepareTweaks(*Sel, DeduplicatingFilter, FeatureModules)) {
724 Result.TweakRefs.push_back(
TweakRef{T->id(), T->title(), T->kind()});
725 PreparedTweaks.insert(T->id());
726 TweakAvailable.record(1, T->id());
729 CB(std::move(Result));
732 WorkScheduler->runWithAST(
"codeAction", Params.
File, std::move(
Action),
744 TweakAttempt.
record(1, TweakID);
747 this](Expected<InputsAndAST> InpAST)
mutable {
749 return CB(InpAST.takeError());
750 auto FS = DirtyFS->view(std::nullopt);
751 auto Selections = tweakSelection(Sel, *InpAST, FS.get());
753 return CB(Selections.takeError());
754 std::optional<llvm::Expected<Tweak::Effect>> Effect;
757 for (
const auto &Selection : *Selections) {
758 auto T =
prepareTweak(TweakID, *Selection, FeatureModules);
760 Effect = (*T)->apply(*Selection);
763 Effect = T.takeError();
765 assert(Effect &&
"Expected at least one selection");
766 if (*Effect && (*Effect)->FormatEdits) {
768 for (
auto &It : (*Effect)->ApplyEdits) {
770 format::FormatStyle Style =
773 elog(
"Failed to format {0}: {1}", It.first(), std::move(Err));
776 TweakFailed.
record(1, TweakID);
778 return CB(std::move(*Effect));
780 WorkScheduler->runWithAST(
"ApplyTweak",
File, std::move(
Action));
784 Callback<std::vector<LocatedSymbol>> CB) {
786 this](llvm::Expected<InputsAndAST> InpAST)
mutable {
788 return CB(InpAST.takeError());
792 WorkScheduler->runWithAST(
"Definitions",
File, std::move(
Action));
803 if (
auto CorrespondingFile =
805 return CB(std::move(CorrespondingFile));
807 this](llvm::Expected<InputsAndAST> InpAST)
mutable {
809 return CB(InpAST.takeError());
812 WorkScheduler->runWithAST(
"SwitchHeaderSource",
Path, std::move(
Action));
818 [
Pos, CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST)
mutable {
820 return CB(InpAST.takeError());
824 WorkScheduler->runWithAST(
"Highlights",
File, std::move(
Action), Transient);
828 Callback<std::optional<HoverInfo>> CB) {
830 this](llvm::Expected<InputsAndAST> InpAST)
mutable {
832 return CB(InpAST.takeError());
834 File, InpAST->Inputs.Contents, *InpAST->Inputs.TFS,
false);
838 WorkScheduler->runWithAST(
"Hover",
File, std::move(
Action), Transient);
843 Callback<std::vector<TypeHierarchyItem>> CB) {
845 this](Expected<InputsAndAST> InpAST)
mutable {
847 return CB(InpAST.takeError());
852 WorkScheduler->runWithAST(
"TypeHierarchy",
File, std::move(
Action));
857 Callback<std::optional<std::vector<TypeHierarchyItem>>> CB) {
858 WorkScheduler->run(
"typeHierarchy/superTypes",
"",
859 [=, CB = std::move(CB)]()
mutable {
865 Callback<std::vector<TypeHierarchyItem>> CB) {
867 "typeHierarchy/subTypes",
"",
873 Callback<std::optional<TypeHierarchyItem>> CB) {
875 "Resolve Type Hierarchy",
"", [=, CB = std::move(CB)]()
mutable {
884 CB = std::move(CB)](Expected<InputsAndAST> InpAST)
mutable {
886 return CB(InpAST.takeError());
889 WorkScheduler->runWithAST(
"CallHierarchy",
File, std::move(
Action));
894 Callback<std::vector<CallHierarchyIncomingCall>> CB) {
895 WorkScheduler->run(
"Incoming Calls",
"",
896 [CB = std::move(CB), Item,
this]()
mutable {
902 Callback<std::vector<InlayHint>> CB) {
903 auto Action = [RestrictRange(std::move(RestrictRange)),
904 CB = std::move(CB)](Expected<InputsAndAST> InpAST)
mutable {
906 return CB(InpAST.takeError());
909 WorkScheduler->runWithAST(
"InlayHints",
File, std::move(
Action), Transient);
918 llvm::StringRef Query,
int Limit,
919 Callback<std::vector<SymbolInformation>> CB) {
921 "getWorkspaceSymbols",
"",
922 [Query = Query.str(), Limit, CB = std::move(CB),
this]()
mutable {
923 CB(clangd::getWorkspaceSymbols(Query, Limit, Index,
924 WorkspaceRoot.value_or(
"")));
929 Callback<std::vector<DocumentSymbol>> CB) {
931 [CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST)
mutable {
933 return CB(InpAST.takeError());
936 WorkScheduler->runWithAST(
"DocumentSymbols",
File, std::move(
Action),
941 Callback<std::vector<FoldingRange>> CB) {
944 return CB(llvm::make_error<LSPError>(
945 "trying to compute folding ranges for non-added document",
947 auto Action = [LineFoldingOnly = LineFoldingOnly, CB = std::move(CB),
948 Code = std::move(*
Code)]()
mutable {
953 WorkScheduler->runQuick(
"FoldingRanges",
File, std::move(
Action));
957 Callback<std::vector<LocatedSymbol>> CB) {
959 this](llvm::Expected<InputsAndAST> InpAST)
mutable {
961 return CB(InpAST.takeError());
964 WorkScheduler->runWithAST(
"FindType",
File, std::move(
Action));
970 this](llvm::Expected<InputsAndAST> InpAST)
mutable {
972 return CB(InpAST.takeError());
976 WorkScheduler->runWithAST(
"Implementations",
File, std::move(
Action));
982 auto Action = [
Pos, Limit, AddContainer, CB = std::move(CB),
983 this](llvm::Expected<InputsAndAST> InpAST)
mutable {
985 return CB(InpAST.takeError());
989 WorkScheduler->runWithAST(
"References",
File, std::move(
Action));
993 Callback<std::vector<SymbolDetails>> CB) {
995 [
Pos, CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST)
mutable {
997 return CB(InpAST.takeError());
1001 WorkScheduler->runWithAST(
"SymbolInfo",
File, std::move(
Action));
1005 const std::vector<Position> &Positions,
1006 Callback<std::vector<SelectionRange>> CB) {
1007 auto Action = [Positions, CB = std::move(CB)](
1008 llvm::Expected<InputsAndAST> InpAST)
mutable {
1010 return CB(InpAST.takeError());
1011 std::vector<SelectionRange> Result;
1012 for (
const auto &
Pos : Positions) {
1014 Result.push_back(std::move(*
Range));
1016 return CB(
Range.takeError());
1018 CB(std::move(Result));
1020 WorkScheduler->runWithAST(
"SemanticRanges",
File, std::move(
Action));
1024 Callback<std::vector<DocumentLink>> CB) {
1026 [CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST)
mutable {
1028 return CB(InpAST.takeError());
1031 WorkScheduler->runWithAST(
"DocumentLinks",
File, std::move(
Action),
1038 auto Action = [CB = std::move(CB),
1039 PublishInactiveRegions = PublishInactiveRegions](
1040 llvm::Expected<InputsAndAST> InpAST)
mutable {
1042 return CB(InpAST.takeError());
1048 WorkScheduler->runWithAST(
"SemanticHighlights",
File, std::move(
Action),
1053 Callback<std::optional<ASTNode>> CB) {
1055 [R, CB(std::move(CB))](llvm::Expected<InputsAndAST> Inputs)
mutable {
1057 return CB(Inputs.takeError());
1061 auto Node = DynTypedNode::create(
1062 *Inputs->AST.getASTContext().getTranslationUnitDecl());
1064 Inputs->AST.getASTContext()));
1066 unsigned Start, End;
1070 return CB(
Offset.takeError());
1074 return CB(
Offset.takeError());
1076 Inputs->AST.getASTContext(), Inputs->AST.getTokens(), Start, End,
1078 if (const SelectionTree::Node *N = T.commonAncestor()) {
1079 CB(dumpAST(N->ASTNode, Inputs->AST.getTokens(),
1080 Inputs->AST.getASTContext()));
1088 WorkScheduler->runWithAST(
"GetAST",
File, std::move(
Action));
1093 WorkScheduler->runWithAST(
Name, File, std::move(
Action));
1098 [CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST)
mutable {
1100 return CB(InpAST.takeError());
1101 return CB(InpAST->AST.getDiagnostics());
1104 WorkScheduler->runWithAST(
"Diagnostics", File, std::move(
Action));
1107llvm::StringMap<TUScheduler::FileStats> ClangdServer::fileStats()
const {
1108 return WorkScheduler->fileStats();
1112ClangdServer::blockUntilIdleForTest(std::optional<double> TimeoutSeconds) {
1116#if defined(__has_feature) && \
1117 (__has_feature(address_sanitizer) || __has_feature(hwaddress_sanitizer) || \
1118 __has_feature(memory_sanitizer) || __has_feature(thread_sanitizer))
1119 if (TimeoutSeconds.has_value())
1120 (*TimeoutSeconds) *= 10;
1125 if (!WorkScheduler->blockUntilIdle(
timeoutSeconds(TimeoutSeconds)))
1128 if (IndexTasks && !IndexTasks->wait(
timeoutSeconds(TimeoutSeconds)))
1140 for (std::optional<double> Timeout :
1141 {TimeoutSeconds, TimeoutSeconds, std::optional<double>(0)}) {
1144 if (BackgroundIdx && !BackgroundIdx->blockUntilIdleForTest(Timeout))
1152 assert(WorkScheduler->blockUntilIdle(Deadline::zero()) &&
1153 "Something scheduled work while we're blocking the main thread!");
1159 DynamicIdx->profile(MT.
child(
"dynamic_index"));
1161 BackgroundIdx->profile(MT.
child(
"background_index"));
1162 WorkScheduler->profile(MT.
child(
"tuscheduler"));
llvm::SmallString< 256U > Name
FeatureModuleSet FeatureModules
const ParseInputs & ParseInput
std::vector< CodeCompletionResult > Results
::clang::DynTypedNode Node
const google::protobuf::Message & M
std::unique_ptr< CompilerInvocation > CI
WantDiagnostics WantDiags
static Factory createDiskBackedStorageFactory(std::function< std::optional< ProjectInfo >(PathRef)> GetProjectInfo)
Interface with hooks for users of ClangdServer to be notified of events.
virtual void onBackgroundIndexProgress(const BackgroundQueue::Stats &Stats)
Called when background indexing tasks are enqueued/started/completed.
virtual void onDiagnosticsReady(PathRef File, llvm::StringRef Version, llvm::ArrayRef< Diag > Diagnostics)
Called by ClangdServer when Diagnostics for File are ready.
ClangdServer(const GlobalCompilationDatabase &CDB, const ThreadsafeFS &TFS, const Options &Opts, Callbacks *Callbacks=nullptr)
Creates a new ClangdServer instance.
void prepareRename(PathRef File, Position Pos, std::optional< std::string > NewName, const RenameOptions &RenameOpts, Callback< RenameResult > CB)
Test the validity of a rename operation.
void prepareCallHierarchy(PathRef File, Position Pos, Callback< std::vector< CallHierarchyItem > > CB)
Get information about call hierarchy for a given position.
void resolveTypeHierarchy(TypeHierarchyItem Item, int Resolve, TypeHierarchyDirection Direction, Callback< std::optional< TypeHierarchyItem > > CB)
Resolve type hierarchy item in the given direction.
void documentSymbols(StringRef File, Callback< std::vector< DocumentSymbol > > CB)
Retrieve the symbols within the specified file.
void workspaceSymbols(StringRef Query, int Limit, Callback< std::vector< SymbolInformation > > CB)
Retrieve the top symbols from the workspace matching a query.
void typeHierarchy(PathRef File, Position Pos, int Resolve, TypeHierarchyDirection Direction, Callback< std::vector< TypeHierarchyItem > > CB)
Get information about type hierarchy for a given position.
void formatFile(PathRef File, std::optional< Range > Rng, Callback< tooling::Replacements > CB)
Run formatting for the File with content Code.
void removeDocument(PathRef File)
Remove File from list of tracked files, schedule a request to free resources associated with it.
void addDocument(PathRef File, StringRef Contents, llvm::StringRef Version="null", WantDiagnostics WD=WantDiagnostics::Auto, bool ForceRebuild=false)
Add a File to the list of tracked C++ files or update the contents if File is already tracked.
void findDocumentHighlights(PathRef File, Position Pos, Callback< std::vector< DocumentHighlight > > CB)
Get document highlights for a given position.
static std::function< Context(PathRef)> createConfiguredContextProvider(const config::Provider *Provider, ClangdServer::Callbacks *)
Creates a context provider that loads and installs config.
void signatureHelp(PathRef File, Position Pos, MarkupKind DocumentationFormat, Callback< SignatureHelp > CB)
Provide signature help for File at Pos.
void findReferences(PathRef File, Position Pos, uint32_t Limit, bool AddContainer, Callback< ReferencesResult > CB)
Retrieve locations for symbol references.
void switchSourceHeader(PathRef Path, Callback< std::optional< clangd::Path > > CB)
Switch to a corresponding source file when given a header file, and vice versa.
void findType(PathRef File, Position Pos, Callback< std::vector< LocatedSymbol > > CB)
Retrieve symbols for types referenced at Pos.
void findImplementations(PathRef File, Position Pos, Callback< std::vector< LocatedSymbol > > CB)
Retrieve implementations for virtual method.
static Options optsForTest()
void subTypes(const TypeHierarchyItem &Item, Callback< std::vector< TypeHierarchyItem > > CB)
Get direct children of a type hierarchy item.
void semanticRanges(PathRef File, const std::vector< Position > &Pos, Callback< std::vector< SelectionRange > > CB)
Get semantic ranges around a specified position in a file.
void applyTweak(PathRef File, Range Sel, StringRef ID, Callback< Tweak::Effect > CB)
Apply the code tweak with a specified ID.
void semanticHighlights(PathRef File, Callback< std::vector< HighlightingToken > >)
void getAST(PathRef File, std::optional< Range > R, Callback< std::optional< ASTNode > > CB)
Describe the AST subtree for a piece of code.
void symbolInfo(PathRef File, Position Pos, Callback< std::vector< SymbolDetails > > CB)
Get symbol info for given position.
void onFileEvent(const DidChangeWatchedFilesParams &Params)
Called when an event occurs for a watched file in the workspace.
void superTypes(const TypeHierarchyItem &Item, Callback< std::optional< std::vector< TypeHierarchyItem > > > CB)
Get direct parents of a type hierarchy item.
void findHover(PathRef File, Position Pos, Callback< std::optional< HoverInfo > > CB)
Get code hover for a given position.
void formatOnType(PathRef File, Position Pos, StringRef TriggerText, Callback< std::vector< TextEdit > > CB)
Run formatting after TriggerText was typed at Pos in File with content Code.
void rename(PathRef File, Position Pos, llvm::StringRef NewName, const RenameOptions &Opts, Callback< RenameResult > CB)
Rename all occurrences of the symbol at the Pos in File to NewName.
void codeAction(const CodeActionInputs &Inputs, Callback< CodeActionResult > CB)
Surface code actions (quick-fixes for diagnostics, or available code tweaks) for a given range in a f...
void locateSymbolAt(PathRef File, Position Pos, Callback< std::vector< LocatedSymbol > > CB)
Find declaration/definition locations of symbol at a specified position.
void incomingCalls(const CallHierarchyItem &Item, Callback< std::vector< CallHierarchyIncomingCall > >)
Resolve incoming calls for a given call hierarchy item.
void inlayHints(PathRef File, std::optional< Range > RestrictRange, Callback< std::vector< InlayHint > >)
Resolve inlay hints for a given document.
void codeComplete(PathRef File, Position Pos, const clangd::CodeCompleteOptions &Opts, Callback< CodeCompleteResult > CB)
Run code completion for File at Pos.
void reparseOpenFilesIfNeeded(llvm::function_ref< bool(llvm::StringRef File)> Filter)
Requests a reparse of currently opened files using their latest source.
void foldingRanges(StringRef File, Callback< std::vector< FoldingRange > > CB)
Retrieve ranges that can be used to fold code within the specified file.
void documentLinks(PathRef File, Callback< std::vector< DocumentLink > > CB)
Get all document links in a file.
std::shared_ptr< const std::string > getDraft(PathRef File) const
Gets the contents of a currently tracked file.
A context is an immutable container for per-request data that must be propagated through layers that ...
Context clone() const
Clone this context object.
static const Context & current()
Returns the context for the current thread, creating it if needed.
static Deadline infinity()
std::vector< Path > getActiveFiles() const
std::optional< Draft > getDraft(PathRef File) const
void removeDraft(PathRef File)
Remove the draft from the store.
std::string addDraft(PathRef File, llvm::StringRef Version, StringRef Contents)
Replace contents of the draft for File with Contents.
A FeatureModule contributes a vertical feature to clangd.
This manages symbols from files and an in-memory index on all symbols.
Provides compilation arguments used for parsing C and C++ files.
PreambleThrottler controls which preambles can build at any given time.
static bool createEach(ASTContext &AST, const syntax::TokenBuffer &Tokens, unsigned Begin, unsigned End, llvm::function_ref< bool(SelectionTree)> Func)
Interface for symbol indexes that can be used for searching or matching symbols among a set of symbol...
Handles running tasks for ClangdServer and managing the resources (e.g., preambles and ASTs) for open...
@ StaleOrAbsent
Besides accepting stale preamble, this also allow preamble to be absent (not ready or failed to build...
@ Stale
The preamble may be generated from an older version of the file.
Wrapper for vfs::FileSystem for use in multithreaded programs like clangd.
llvm::IntrusiveRefCntPtr< llvm::vfs::FileSystem > view(std::nullopt_t CWD) const
Obtain a vfs::FileSystem with an arbitrary initial working directory.
An interface base for small context-sensitive refactoring actions.
A source of configuration fragments.
Config getConfig(const Params &, DiagnosticCallback) const
Build a config based on this provider.
Records an event whose duration is the lifetime of the Span object.
@ Changed
The file got changed.
std::vector< TypeHierarchyItem > subTypes(const TypeHierarchyItem &Item, const SymbolIndex *Index)
Returns direct children of a TypeHierarchyItem.
std::optional< std::vector< TypeHierarchyItem > > superTypes(const TypeHierarchyItem &Item, const SymbolIndex *Index)
Returns direct parents of a TypeHierarchyItem using SymbolIDs stored inside the item.
std::vector< CallHierarchyIncomingCall > incomingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index)
std::vector< HighlightingToken > getSemanticHighlightings(ParsedAST &AST, bool IncludeInactiveRegionTokens)
llvm::Expected< std::unique_ptr< Tweak > > prepareTweak(StringRef ID, const Tweak::Selection &S, const FeatureModuleSet *Modules)
ASTNode dumpAST(const DynTypedNode &N, const syntax::TokenBuffer &Tokens, const ASTContext &Ctx)
std::vector< DocumentHighlight > findDocumentHighlights(ParsedAST &AST, Position Pos)
Returns highlights for all usages of a symbol at Pos.
std::string Path
A typedef to represent a file path.
llvm::Expected< std::vector< FoldingRange > > getFoldingRanges(ParsedAST &AST)
Returns a list of ranges whose contents might be collapsible in an editor.
std::vector< DocumentLink > getDocumentLinks(ParsedAST &AST)
Get all document links.
std::vector< SymbolDetails > getSymbolInfo(ParsedAST &AST, Position Pos)
Get info about symbols at Pos.
void vlog(const char *Fmt, Ts &&... Vals)
llvm::Error reformatEdit(Edit &E, const format::FormatStyle &Style)
Formats the edits and code around it according to Style.
std::vector< LocatedSymbol > findType(ParsedAST &AST, Position Pos, const SymbolIndex *Index)
Returns symbols for types referenced at Pos.
llvm::Expected< RenameResult > rename(const RenameInputs &RInputs)
Renames all occurrences of the symbol.
std::vector< TypeHierarchyItem > getTypeHierarchy(ParsedAST &AST, Position Pos, int ResolveLevels, TypeHierarchyDirection Direction, const SymbolIndex *Index, PathRef TUPath)
Get type hierarchy information at Pos.
llvm::Error error(std::error_code EC, const char *Fmt, Ts &&... Vals)
ReferencesResult findReferences(ParsedAST &AST, Position Pos, uint32_t Limit, const SymbolIndex *Index, bool AddContext)
Returns references of the symbol at a specified Pos.
llvm::unique_function< void(llvm::Expected< T >)> Callback
A Callback<T> is a void function that accepts Expected<T>.
std::optional< HoverInfo > getHover(ParsedAST &AST, Position Pos, const format::FormatStyle &Style, const SymbolIndex *Index)
Get the hover information when hovering at Pos.
std::vector< tooling::Replacement > formatIncremental(llvm::StringRef OriginalCode, unsigned OriginalCursor, llvm::StringRef InsertedText, format::FormatStyle Style)
Applies limited formatting around new InsertedText.
std::vector< LocatedSymbol > locateSymbolAt(ParsedAST &AST, Position Pos, const SymbolIndex *Index)
Get definition of symbol at a specified Pos.
llvm::Expected< SelectionRange > getSemanticRanges(ParsedAST &AST, Position Pos)
Returns the list of all interesting ranges around the Position Pos.
llvm::Expected< size_t > positionToOffset(llvm::StringRef Code, Position P, bool AllowColumnsBeyondLineLength)
Turn a [line, column] pair into an offset in Code.
llvm::Expected< std::vector< DocumentSymbol > > getDocumentSymbols(ParsedAST &AST)
Retrieves the symbols contained in the "main file" section of an AST in the same order that they appe...
std::optional< Path > getCorrespondingHeaderOrSource(PathRef OriginalFile, llvm::IntrusiveRefCntPtr< llvm::vfs::FileSystem > VFS)
Given a header file, returns the best matching source file, and vice visa.
Diag toDiag(const llvm::SMDiagnostic &D, Diag::DiagSource Source)
std::vector< std::unique_ptr< Tweak > > prepareTweaks(const Tweak::Selection &S, llvm::function_ref< bool(const Tweak &)> Filter, const FeatureModuleSet *Modules)
Calls prepare() on all tweaks that satisfy the filter, returning those that can run on the selection.
WantDiagnostics
Determines whether diagnostics should be generated for a file snapshot.
@ Auto
Diagnostics must not be generated for this snapshot.
std::vector< LocatedSymbol > findImplementations(ParsedAST &AST, Position Pos, const SymbolIndex *Index)
Returns implementations at a specified Pos:
std::vector< InlayHint > inlayHints(ParsedAST &AST, std::optional< Range > RestrictRange)
Compute and return inlay hints for a file.
int isCancelled(const Context &Ctx)
If the current context is within a cancelled task, returns the reason.
void resolveTypeHierarchy(TypeHierarchyItem &Item, int ResolveLevels, TypeHierarchyDirection Direction, const SymbolIndex *Index)
std::vector< Range > getInactiveRegions(ParsedAST &AST)
Deadline timeoutSeconds(std::optional< double > Seconds)
Makes a deadline from a timeout in seconds. std::nullopt means wait forever.
CodeCompleteResult codeComplete(PathRef FileName, Position Pos, const PreambleData *Preamble, const ParseInputs &ParseInput, CodeCompleteOptions Opts, SpeculativeFuzzyFind *SpecFuzzyFind)
Gets code completions at a specified Pos in FileName.
llvm::StringRef PathRef
A typedef to represent a ref to file path.
SignatureHelp signatureHelp(PathRef FileName, Position Pos, const PreambleData &Preamble, const ParseInputs &ParseInput, MarkupKind DocumentationFormat)
Get signature help at a specified Pos in FileName.
void elog(const char *Fmt, Ts &&... Vals)
TextEdit replacementToEdit(llvm::StringRef Code, const tooling::Replacement &R)
SymbolSlab indexStandardLibrary(llvm::StringRef HeaderSources, std::unique_ptr< CompilerInvocation > CI, const StdLibLocation &Loc, const ThreadsafeFS &TFS)
std::vector< CallHierarchyItem > prepareCallHierarchy(ParsedAST &AST, Position Pos, PathRef TUPath)
Get call hierarchy information at Pos.
format::FormatStyle getFormatStyleForFile(llvm::StringRef File, llvm::StringRef Content, const ThreadsafeFS &TFS, bool FormatFile)
Choose the clang-format style we should apply to a certain file.
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
std::function< Context(PathRef)> ContextProvider
std::function< void(BackgroundQueue::Stats)> OnProgress
Represents programming constructs like functions or constructors in the context of call hierarchy.
static const llvm::StringLiteral QUICKFIX_KIND
@ AlwaysParse
Block until we can run the parser (e.g.
Settings that express user/project preferences and control clangd behavior.
bool AllScopes
Whether code completion includes results that are not visible in current scopes.
static const Config & current()
Returns the Config of the current Context, or an empty configuration.
struct clang::clangd::Config::@6 Completion
Configures code completion feature.
static DebouncePolicy fixed(clock::duration)
A policy that always returns the same duration, useful for tests.
A top-level diagnostic that may have Notes and Fixes.
std::vector< Fix > Fixes
Alternative fixes for this diagnostic, one should be chosen.
A set of edits generated for a single file.
Shared server facilities needed by the module to get its work done.
Represents a single fix-it that editor can apply to fix the error.
A tree that can be used to represent memory usage of nested components while preserving the hierarchy...
MemoryTree & child(llvm::StringLiteral Name)
No copy of the Name.
The parsed preamble and associated data.
PrecompiledPreamble Preamble
Position start
The range's start position.
Position end
The range's end position.
Describes the context used to evaluate configuration fragments.
std::chrono::steady_clock::time_point FreshTime
Hint that stale data is OK to improve performance (e.g.
llvm::StringRef Path
Absolute path to a source file we're applying the config to.
Represents measurements of clangd events, e.g.
@ Counter
An aggregate number whose rate of change over time is meaningful.
@ Distribution
A distribution of values with a meaningful mean and count.
void record(double Value, llvm::StringRef Label="") const
Records a measurement for this metric to active tracer.