clang-tools 20.0.0git
SyncAPI.cpp
Go to the documentation of this file.
1//===--- SyncAPI.cpp - Sync version of ClangdServer's API --------*- 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 "SyncAPI.h"
10#include "Protocol.h"
11#include "index/Index.h"
12#include <optional>
13
14namespace clang {
15namespace clangd {
16
18 llvm::StringRef Contents, llvm::StringRef Version,
19 WantDiagnostics WantDiags, bool ForceRebuild) {
20 Server.addDocument(File, Contents, Version, WantDiags, ForceRebuild);
21 if (!Server.blockUntilIdleForTest())
22 llvm_unreachable("not idle after addDocument");
23}
24
25namespace {
26/// A helper that waits for async callbacks to fire and exposes their result in
27/// the output variable. Intended to be used in the following way:
28/// T Result;
29/// someAsyncFunc(Param1, Param2, /*Callback=*/capture(Result));
30template <typename T> struct CaptureProxy {
31 CaptureProxy(std::optional<T> &Target) : Target(&Target) { assert(!Target); }
32
33 CaptureProxy(const CaptureProxy &) = delete;
34 CaptureProxy &operator=(const CaptureProxy &) = delete;
35 // We need move ctor to return a value from the 'capture' helper.
36 CaptureProxy(CaptureProxy &&Other) : Target(Other.Target) {
37 Other.Target = nullptr;
38 }
39 CaptureProxy &operator=(CaptureProxy &&) = delete;
40
41 operator llvm::unique_function<void(T)>() && {
42 assert(!Future.valid() && "conversion to callback called multiple times");
43 Future = Promise.get_future();
44 return [Promise = std::move(Promise)](T Value) mutable {
45 Promise.set_value(std::make_shared<T>(std::move(Value)));
46 };
47 }
48
49 ~CaptureProxy() {
50 if (!Target)
51 return;
52 assert(Future.valid() && "conversion to callback was not called");
53 assert(!Target->has_value());
54 Target->emplace(std::move(*Future.get()));
55 }
56
57private:
58 std::optional<T> *Target;
59 // Using shared_ptr to workaround compilation errors with MSVC.
60 // MSVC only allows default-constructible and copyable objects as future<>
61 // arguments.
62 std::promise<std::shared_ptr<T>> Promise;
63 std::future<std::shared_ptr<T>> Future;
64};
65
66template <typename T> CaptureProxy<T> capture(std::optional<T> &Target) {
67 return CaptureProxy<T>(Target);
68}
69} // namespace
70
71llvm::Expected<CodeCompleteResult>
74 std::optional<llvm::Expected<CodeCompleteResult>> Result;
75 Server.codeComplete(File, Pos, Opts, capture(Result));
76 return std::move(*Result);
77}
78
79llvm::Expected<SignatureHelp> runSignatureHelp(ClangdServer &Server,
81 MarkupKind DocumentationFormat) {
82 std::optional<llvm::Expected<SignatureHelp>> Result;
83 Server.signatureHelp(File, Pos, DocumentationFormat, capture(Result));
84 return std::move(*Result);
85}
86
87llvm::Expected<std::vector<LocatedSymbol>>
89 std::optional<llvm::Expected<std::vector<LocatedSymbol>>> Result;
90 Server.locateSymbolAt(File, Pos, capture(Result));
91 return std::move(*Result);
92}
93
94llvm::Expected<std::vector<DocumentHighlight>>
96 std::optional<llvm::Expected<std::vector<DocumentHighlight>>> Result;
97 Server.findDocumentHighlights(File, Pos, capture(Result));
98 return std::move(*Result);
99}
100
101llvm::Expected<RenameResult> runRename(ClangdServer &Server, PathRef File,
102 Position Pos, llvm::StringRef NewName,
103 const RenameOptions &RenameOpts) {
104 std::optional<llvm::Expected<RenameResult>> Result;
105 Server.rename(File, Pos, NewName, RenameOpts, capture(Result));
106 return std::move(*Result);
107}
108
109llvm::Expected<RenameResult>
111 std::optional<std::string> NewName,
112 const RenameOptions &RenameOpts) {
113 std::optional<llvm::Expected<RenameResult>> Result;
114 Server.prepareRename(File, Pos, NewName, RenameOpts, capture(Result));
115 return std::move(*Result);
116}
117
118llvm::Expected<tooling::Replacements>
119runFormatFile(ClangdServer &Server, PathRef File, std::optional<Range> Rng) {
120 std::optional<llvm::Expected<tooling::Replacements>> Result;
121 Server.formatFile(File, Rng, capture(Result));
122 return std::move(*Result);
123}
124
125SymbolSlab runFuzzyFind(const SymbolIndex &Index, llvm::StringRef Query) {
127 Req.Query = std::string(Query);
128 Req.AnyScope = true;
129 return runFuzzyFind(Index, Req);
130}
131
134 Index.fuzzyFind(Req, [&](const Symbol &Sym) { Builder.insert(Sym); });
135 return std::move(Builder).build();
136}
137
139 RefsRequest Req;
140 Req.IDs = {ID};
141 RefSlab::Builder Slab;
142 Index.refs(Req, [&](const Ref &S) { Slab.insert(ID, S); });
143 return std::move(Slab).build();
144}
145
146llvm::Expected<std::vector<SelectionRange>>
148 const std::vector<Position> &Pos) {
149 std::optional<llvm::Expected<std::vector<SelectionRange>>> Result;
150 Server.semanticRanges(File, Pos, capture(Result));
151 return std::move(*Result);
152}
153
154llvm::Expected<std::optional<clangd::Path>>
156 std::optional<llvm::Expected<std::optional<clangd::Path>>> Result;
157 Server.switchSourceHeader(File, capture(Result));
158 return std::move(*Result);
159}
160
162 llvm::function_ref<void(InputsAndAST)> Action) {
163 llvm::Error Result = llvm::Error::success();
164 Notification Done;
165 Server.customAction(File, "Custom", [&](llvm::Expected<InputsAndAST> AST) {
166 if (!AST)
167 Result = AST.takeError();
168 else
169 Action(*AST);
170 Done.notify();
171 });
172 Done.wait();
173 return Result;
174}
175
176} // namespace clangd
177} // namespace clang
CodeCompletionBuilder Builder
FieldAction Action
size_t Pos
WantDiagnostics WantDiags
Manages a collection of source files and derived data (ASTs, indexes), and provides language-aware fe...
Definition: ClangdServer.h:59
A threadsafe flag that is initially clear.
Definition: Threading.h:91
RefSlab::Builder is a mutable container that can 'freeze' to RefSlab.
Definition: Ref.h:132
void insert(const SymbolID &ID, const Ref &S)
Adds a ref to the slab. Deep copy: Strings will be owned by the slab.
Definition: Ref.cpp:36
An efficient structure of storing large set of symbol references in memory.
Definition: Ref.h:108
Interface for symbol indexes that can be used for searching or matching symbols among a set of symbol...
Definition: Index.h:113
SymbolSlab::Builder is a mutable container that can 'freeze' to SymbolSlab.
Definition: Symbol.h:222
An immutable symbol container that stores a set of symbols.
Definition: Symbol.h:199
llvm::Expected< std::optional< clangd::Path > > runSwitchHeaderSource(ClangdServer &Server, PathRef File)
Definition: SyncAPI.cpp:155
llvm::Expected< tooling::Replacements > runFormatFile(ClangdServer &Server, PathRef File, std::optional< Range > Rng)
Definition: SyncAPI.cpp:119
llvm::Expected< RenameResult > runRename(ClangdServer &Server, PathRef File, Position Pos, llvm::StringRef NewName, const RenameOptions &RenameOpts)
Definition: SyncAPI.cpp:101
llvm::Expected< std::vector< SelectionRange > > runSemanticRanges(ClangdServer &Server, PathRef File, const std::vector< Position > &Pos)
Definition: SyncAPI.cpp:147
llvm::Expected< CodeCompleteResult > runCodeComplete(ClangdServer &Server, PathRef File, Position Pos, clangd::CodeCompleteOptions Opts)
Definition: SyncAPI.cpp:72
llvm::Expected< SignatureHelp > runSignatureHelp(ClangdServer &Server, PathRef File, Position Pos, MarkupKind DocumentationFormat)
Definition: SyncAPI.cpp:79
RefSlab getRefs(const SymbolIndex &Index, SymbolID ID)
Definition: SyncAPI.cpp:138
void runAddDocument(ClangdServer &Server, PathRef File, llvm::StringRef Contents, llvm::StringRef Version, WantDiagnostics WantDiags, bool ForceRebuild)
Definition: SyncAPI.cpp:17
llvm::Expected< std::vector< LocatedSymbol > > runLocateSymbolAt(ClangdServer &Server, PathRef File, Position Pos)
Definition: SyncAPI.cpp:88
WantDiagnostics
Determines whether diagnostics should be generated for a file snapshot.
Definition: TUScheduler.h:53
llvm::Error runCustomAction(ClangdServer &Server, PathRef File, llvm::function_ref< void(InputsAndAST)> Action)
Definition: SyncAPI.cpp:161
llvm::StringRef PathRef
A typedef to represent a ref to file path.
Definition: Path.h:29
llvm::Expected< std::vector< DocumentHighlight > > runFindDocumentHighlights(ClangdServer &Server, PathRef File, Position Pos)
Definition: SyncAPI.cpp:95
SymbolSlab runFuzzyFind(const SymbolIndex &Index, llvm::StringRef Query)
Definition: SyncAPI.cpp:125
llvm::Expected< RenameResult > runPrepareRename(ClangdServer &Server, PathRef File, Position Pos, std::optional< std::string > NewName, const RenameOptions &RenameOpts)
Definition: SyncAPI.cpp:110
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
std::string Query
A query string for the fuzzy find.
Definition: Index.h:29
bool AnyScope
If set to true, allow symbols from any scope.
Definition: Index.h:39
Represents a symbol occurrence in the source file.
Definition: Ref.h:85
llvm::DenseSet< SymbolID > IDs
Definition: Index.h:69
The class presents a C++ symbol, e.g.
Definition: Symbol.h:39