clang-tools  15.0.0git
ClangdServer.h
Go to the documentation of this file.
1 //===--- ClangdServer.h - 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 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_CLANGDSERVER_H
10 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_CLANGDSERVER_H
11 
12 #include "CodeComplete.h"
13 #include "ConfigProvider.h"
14 #include "Diagnostics.h"
15 #include "DraftStore.h"
16 #include "FeatureModule.h"
18 #include "Hover.h"
19 #include "Protocol.h"
20 #include "SemanticHighlighting.h"
21 #include "TUScheduler.h"
22 #include "XRefs.h"
23 #include "index/Background.h"
24 #include "index/FileIndex.h"
25 #include "index/Index.h"
26 #include "refactor/Rename.h"
27 #include "refactor/Tweak.h"
28 #include "support/Function.h"
29 #include "support/MemoryTree.h"
30 #include "support/Path.h"
31 #include "support/ThreadsafeFS.h"
32 #include "clang/Tooling/Core/Replacement.h"
33 #include "llvm/ADT/FunctionExtras.h"
34 #include "llvm/ADT/Optional.h"
35 #include "llvm/ADT/StringRef.h"
36 #include <functional>
37 #include <memory>
38 #include <string>
39 #include <type_traits>
40 #include <utility>
41 #include <vector>
42 
43 namespace clang {
44 namespace clangd {
45 /// Manages a collection of source files and derived data (ASTs, indexes),
46 /// and provides language-aware features such as code completion.
47 ///
48 /// The primary client is ClangdLSPServer which exposes these features via
49 /// the Language Server protocol. ClangdServer may also be embedded directly,
50 /// though its API is not stable over time.
51 ///
52 /// ClangdServer should be used from a single thread. Many potentially-slow
53 /// operations have asynchronous APIs and deliver their results on another
54 /// thread.
55 /// Such operations support cancellation: if the caller sets up a cancelable
56 /// context, many operations will notice cancellation and fail early.
57 /// (ClangdLSPServer uses this to implement $/cancelRequest).
58 class ClangdServer {
59 public:
60  /// Interface with hooks for users of ClangdServer to be notified of events.
61  class Callbacks {
62  public:
63  virtual ~Callbacks() = default;
64 
65  /// Called by ClangdServer when \p Diagnostics for \p File are ready.
66  /// These pushed diagnostics might correspond to an older version of the
67  /// file, they do not interfere with "pull-based" ClangdServer::diagnostics.
68  /// May be called concurrently for separate files, not for a single file.
69  virtual void onDiagnosticsReady(PathRef File, llvm::StringRef Version,
70  std::vector<Diag> Diagnostics) {}
71  /// Called whenever the file status is updated.
72  /// May be called concurrently for separate files, not for a single file.
73  virtual void onFileUpdated(PathRef File, const TUStatus &Status) {}
74 
75  /// Called when background indexing tasks are enqueued/started/completed.
76  /// Not called concurrently.
77  virtual void
79 
80  /// Called when the meaning of a source code may have changed without an
81  /// edit. Usually clients assume that responses to requests are valid until
82  /// they next edit the file. If they're invalidated at other times, we
83  /// should tell the client. In particular, when an asynchronous preamble
84  /// build finishes, we can provide more accurate semantic tokens, so we
85  /// should tell the client to refresh.
86  virtual void onSemanticsMaybeChanged(PathRef File) {}
87  };
88  /// Creates a context provider that loads and installs config.
89  /// Errors in loading config are reported as diagnostics via Callbacks.
90  /// (This is typically used as ClangdServer::Options::ContextProvider).
91  static std::function<Context(PathRef)>
94 
95  struct Options {
96  /// To process requests asynchronously, ClangdServer spawns worker threads.
97  /// If this is zero, no threads are spawned. All work is done on the calling
98  /// thread, and callbacks are invoked before "async" functions return.
100 
101  /// AST caching policy. The default is to keep up to 3 ASTs in memory.
103 
104  /// Cached preambles are potentially large. If false, store them on disk.
106 
107  /// If true, ClangdServer builds a dynamic in-memory index for symbols in
108  /// opened files and uses the index to augment code completion results.
110  /// If true, ClangdServer automatically indexes files in the current project
111  /// on background threads. The index is stored in the project root.
112  bool BackgroundIndex = false;
113  llvm::ThreadPriority BackgroundIndexPriority = llvm::ThreadPriority::Low;
114 
115  /// If set, use this index to augment code completion results.
117 
118  /// If set, queried to derive a processing context for some work.
119  /// Usually used to inject Config (see createConfiguredContextProvider).
120  ///
121  /// When the provider is called, the active context will be that inherited
122  /// from the request (e.g. addDocument()), or from the ClangdServer
123  /// constructor if there is no such request (e.g. background indexing).
124  ///
125  /// The path is an absolute path of the file being processed.
126  /// If there is no particular file (e.g. project loading) then it is empty.
127  std::function<Context(PathRef)> ContextProvider;
128 
129  /// The Options provider to use when running clang-tidy. If null, clang-tidy
130  /// checks will be disabled.
132 
133  /// Clangd's workspace root. Relevant for "workspace" operations not bound
134  /// to a particular file.
135  /// FIXME: If not set, should use the current working directory.
136  llvm::Optional<std::string> WorkspaceRoot;
137 
138  /// The resource directory is used to find internal headers, overriding
139  /// defaults and -resource-dir compiler flag).
140  /// If None, ClangdServer calls CompilerInvocation::GetResourcePath() to
141  /// obtain the standard resource directory.
142  llvm::Optional<std::string> ResourceDir = llvm::None;
143 
144  /// Time to wait after a new file version before computing diagnostics.
146  /*Min=*/std::chrono::milliseconds(50),
147  /*Max=*/std::chrono::milliseconds(500),
148  /*RebuildRatio=*/1,
149  };
150 
151  /// Cancel certain requests if the file changes before they begin running.
152  /// This is useful for "transient" actions like enumerateTweaks that were
153  /// likely implicitly generated, and avoids redundant work if clients forget
154  /// to cancel. Clients that always cancel stale requests should clear this.
155  bool ImplicitCancellation = true;
156 
157  /// Clangd will execute compiler drivers matching one of these globs to
158  /// fetch system include path.
159  std::vector<std::string> QueryDriverGlobs;
160 
161  /// Enable preview of FoldingRanges feature.
162  bool FoldingRanges = false;
163 
165  /// If true, use the dirty buffer contents when building Preambles.
166  bool UseDirtyHeaders = false;
167 
168  // If true, parse emplace-like functions in the preamble.
170 
171  explicit operator TUScheduler::Options() const;
172  };
173  // Sensible default options for use in tests.
174  // Features like indexing must be enabled if desired.
175  static Options optsForTest();
176 
177  /// Creates a new ClangdServer instance.
178  ///
179  /// ClangdServer uses \p CDB to obtain compilation arguments for parsing. Note
180  /// that ClangdServer only obtains compilation arguments once for each newly
181  /// added file (i.e., when processing a first call to addDocument) and reuses
182  /// those arguments for subsequent reparses. However, ClangdServer will check
183  /// if compilation arguments changed on calls to forceReparse().
184  ClangdServer(const GlobalCompilationDatabase &CDB, const ThreadsafeFS &TFS,
185  const Options &Opts, Callbacks *Callbacks = nullptr);
186  ~ClangdServer();
187 
188  /// Gets the installed feature module of a given type, if any.
189  /// This exposes access the public interface of feature modules that have one.
190  template <typename Mod> Mod *featureModule() {
191  return FeatureModules ? FeatureModules->get<Mod>() : nullptr;
192  }
193  template <typename Mod> const Mod *featureModule() const {
194  return FeatureModules ? FeatureModules->get<Mod>() : nullptr;
195  }
196 
197  /// Add a \p File to the list of tracked C++ files or update the contents if
198  /// \p File is already tracked. Also schedules parsing of the AST for it on a
199  /// separate thread. When the parsing is complete, DiagConsumer passed in
200  /// constructor will receive onDiagnosticsReady callback.
201  /// Version identifies this snapshot and is propagated to ASTs, preambles,
202  /// diagnostics etc built from it. If empty, a version number is generated.
203  void addDocument(PathRef File, StringRef Contents,
204  llvm::StringRef Version = "null",
206  bool ForceRebuild = false);
207 
208  /// Remove \p File from list of tracked files, schedule a request to free
209  /// resources associated with it. Pending diagnostics for closed files may not
210  /// be delivered, even if requested with WantDiags::Auto or WantDiags::Yes.
211  /// An empty set of diagnostics will be delivered, with Version = "".
212  void removeDocument(PathRef File);
213 
214  /// Requests a reparse of currently opened files using their latest source.
215  /// This will typically only rebuild if something other than the source has
216  /// changed (e.g. the CDB yields different flags, or files included in the
217  /// preamble have been modified).
219  llvm::function_ref<bool(llvm::StringRef File)> Filter);
220 
221  /// Run code completion for \p File at \p Pos.
222  ///
223  /// This method should only be called for currently tracked files.
224  void codeComplete(PathRef File, Position Pos,
225  const clangd::CodeCompleteOptions &Opts,
227 
228  /// Provide signature help for \p File at \p Pos. This method should only be
229  /// called for tracked files.
230  void signatureHelp(PathRef File, Position Pos, MarkupKind DocumentationFormat,
232 
233  /// Find declaration/definition locations of symbol at a specified position.
234  void locateSymbolAt(PathRef File, Position Pos,
235  Callback<std::vector<LocatedSymbol>> CB);
236 
237  /// Switch to a corresponding source file when given a header file, and vice
238  /// versa.
240  Callback<llvm::Optional<clangd::Path>> CB);
241 
242  /// Get document highlights for a given position.
244  Callback<std::vector<DocumentHighlight>> CB);
245 
246  /// Get code hover for a given position.
247  void findHover(PathRef File, Position Pos,
248  Callback<llvm::Optional<HoverInfo>> CB);
249 
250  /// Get information about type hierarchy for a given position.
251  void typeHierarchy(PathRef File, Position Pos, int Resolve,
252  TypeHierarchyDirection Direction,
253  Callback<llvm::Optional<TypeHierarchyItem>> CB);
254 
255  /// Resolve type hierarchy item in the given direction.
256  void resolveTypeHierarchy(TypeHierarchyItem Item, int Resolve,
257  TypeHierarchyDirection Direction,
258  Callback<llvm::Optional<TypeHierarchyItem>> CB);
259 
260  /// Get information about call hierarchy for a given position.
262  Callback<std::vector<CallHierarchyItem>> CB);
263 
264  /// Resolve incoming calls for a given call hierarchy item.
265  void incomingCalls(const CallHierarchyItem &Item,
266  Callback<std::vector<CallHierarchyIncomingCall>>);
267 
268  /// Resolve inlay hints for a given document.
269  void inlayHints(PathRef File, llvm::Optional<Range> RestrictRange,
270  Callback<std::vector<InlayHint>>);
271 
272  /// Retrieve the top symbols from the workspace matching a query.
273  void workspaceSymbols(StringRef Query, int Limit,
274  Callback<std::vector<SymbolInformation>> CB);
275 
276  /// Retrieve the symbols within the specified file.
277  void documentSymbols(StringRef File,
278  Callback<std::vector<DocumentSymbol>> CB);
279 
280  /// Retrieve ranges that can be used to fold code within the specified file.
281  void foldingRanges(StringRef File, Callback<std::vector<FoldingRange>> CB);
282 
283  /// Retrieve implementations for virtual method.
285  Callback<std::vector<LocatedSymbol>> CB);
286 
287  /// Retrieve symbols for types referenced at \p Pos.
288  void findType(PathRef File, Position Pos,
289  Callback<std::vector<LocatedSymbol>> CB);
290 
291  /// Retrieve locations for symbol references.
292  void findReferences(PathRef File, Position Pos, uint32_t Limit,
294 
295  /// Run formatting for the \p File with content \p Code.
296  /// If \p Rng is non-null, formats only that region.
297  void formatFile(PathRef File, llvm::Optional<Range> Rng,
299 
300  /// Run formatting after \p TriggerText was typed at \p Pos in \p File with
301  /// content \p Code.
302  void formatOnType(PathRef File, Position Pos, StringRef TriggerText,
303  Callback<std::vector<TextEdit>> CB);
304 
305  /// Test the validity of a rename operation.
306  ///
307  /// If NewName is provided, it performs a name validation.
308  void prepareRename(PathRef File, Position Pos,
309  llvm::Optional<std::string> NewName,
310  const RenameOptions &RenameOpts,
312 
313  /// Rename all occurrences of the symbol at the \p Pos in \p File to
314  /// \p NewName.
315  /// If WantFormat is false, the final TextEdit will be not formatted,
316  /// embedders could use this method to get all occurrences of the symbol (e.g.
317  /// highlighting them in prepare stage).
318  void rename(PathRef File, Position Pos, llvm::StringRef NewName,
319  const RenameOptions &Opts, Callback<RenameResult> CB);
320 
321  struct TweakRef {
322  std::string ID; /// ID to pass for applyTweak.
323  std::string Title; /// A single-line message to show in the UI.
324  llvm::StringLiteral Kind;
325  };
326  /// Enumerate the code tweaks available to the user at a specified point.
327  /// Tweaks where Filter returns false will not be checked or included.
328  void enumerateTweaks(PathRef File, Range Sel,
329  llvm::unique_function<bool(const Tweak &)> Filter,
330  Callback<std::vector<TweakRef>> CB);
331 
332  /// Apply the code tweak with a specified \p ID.
333  void applyTweak(PathRef File, Range Sel, StringRef ID,
335 
336  /// Called when an event occurs for a watched file in the workspace.
337  void onFileEvent(const DidChangeWatchedFilesParams &Params);
338 
339  /// Get symbol info for given position.
340  /// Clangd extension - not part of official LSP.
341  void symbolInfo(PathRef File, Position Pos,
342  Callback<std::vector<SymbolDetails>> CB);
343 
344  /// Get semantic ranges around a specified position in a file.
345  void semanticRanges(PathRef File, const std::vector<Position> &Pos,
346  Callback<std::vector<SelectionRange>> CB);
347 
348  /// Get all document links in a file.
349  void documentLinks(PathRef File, Callback<std::vector<DocumentLink>> CB);
350 
351  void semanticHighlights(PathRef File,
352  Callback<std::vector<HighlightingToken>>);
353 
354  /// Describe the AST subtree for a piece of code.
355  void getAST(PathRef File, llvm::Optional<Range> R,
356  Callback<llvm::Optional<ASTNode>> CB);
357 
358  /// Runs an arbitrary action that has access to the AST of the specified file.
359  /// The action will execute on one of ClangdServer's internal threads.
360  /// The AST is only valid for the duration of the callback.
361  /// As with other actions, the file must have been opened.
362  void customAction(PathRef File, llvm::StringRef Name,
364 
365  /// Fetches diagnostics for current version of the \p File. This might fail if
366  /// server is busy (building a preamble) and would require a long time to
367  /// prepare diagnostics. If it fails, clients should wait for
368  /// onSemanticsMaybeChanged and then retry.
369  /// These 'pulled' diagnostics do not interfere with the diagnostics 'pushed'
370  /// to Callbacks::onDiagnosticsReady, and clients may use either or both.
371  void diagnostics(PathRef File, Callback<std::vector<Diag>> CB);
372 
373  /// Returns estimated memory usage and other statistics for each of the
374  /// currently open files.
375  /// Overall memory usage of clangd may be significantly more than reported
376  /// here, as this metric does not account (at least) for:
377  /// - memory occupied by static and dynamic index,
378  /// - memory required for in-flight requests,
379  /// FIXME: those metrics might be useful too, we should add them.
380  llvm::StringMap<TUScheduler::FileStats> fileStats() const;
381 
382  /// Gets the contents of a currently tracked file. Returns nullptr if the file
383  /// isn't being tracked.
384  std::shared_ptr<const std::string> getDraft(PathRef File) const;
385 
386  // Blocks the main thread until the server is idle. Only for use in tests.
387  // Returns false if the timeout expires.
388  // FIXME: various subcomponents each get the full timeout, so it's more of
389  // an order of magnitude than a hard deadline.
390  LLVM_NODISCARD bool
391  blockUntilIdleForTest(llvm::Optional<double> TimeoutSeconds = 10);
392 
393  /// Builds a nested representation of memory used by components.
394  void profile(MemoryTree &MT) const;
395 
396 private:
397  FeatureModuleSet *FeatureModules;
398  const GlobalCompilationDatabase &CDB;
399  const ThreadsafeFS &getHeaderFS() const {
400  return UseDirtyHeaders ? *DirtyFS : TFS;
401  }
402  const ThreadsafeFS &TFS;
403 
404  Path ResourceDir;
405  // The index used to look up symbols. This could be:
406  // - null (all index functionality is optional)
407  // - the dynamic index owned by ClangdServer (DynamicIdx)
408  // - the static index passed to the constructor
409  // - a merged view of a static and dynamic index (MergedIndex)
410  const SymbolIndex *Index = nullptr;
411  // If present, an index of symbols in open files. Read via *Index.
412  std::unique_ptr<FileIndex> DynamicIdx;
413  // If present, the new "auto-index" maintained in background threads.
414  std::unique_ptr<BackgroundIndex> BackgroundIdx;
415  // Storage for merged views of the various indexes.
416  std::vector<std::unique_ptr<SymbolIndex>> MergedIdx;
417 
418  // When set, provides clang-tidy options for a specific file.
419  TidyProviderRef ClangTidyProvider;
420 
421  bool UseDirtyHeaders = false;
422 
423  bool PreambleParseForwardingFunctions = false;
424 
425  // GUARDED_BY(CachedCompletionFuzzyFindRequestMutex)
426  llvm::StringMap<llvm::Optional<FuzzyFindRequest>>
427  CachedCompletionFuzzyFindRequestByFile;
428  mutable std::mutex CachedCompletionFuzzyFindRequestMutex;
429 
430  llvm::Optional<std::string> WorkspaceRoot;
431  llvm::Optional<AsyncTaskRunner> IndexTasks; // for stdlib indexing.
432  llvm::Optional<TUScheduler> WorkScheduler;
433  // Invalidation policy used for actions that we assume are "transient".
435 
436  // Store of the current versions of the open documents.
437  // Only written from the main thread (despite being threadsafe).
438  DraftStore DraftMgr;
439 
440  std::unique_ptr<ThreadsafeFS> DirtyFS;
441 };
442 
443 } // namespace clangd
444 } // namespace clang
445 
446 #endif
clang::clangd::ClangdServer::TweakRef::Kind
llvm::StringLiteral Kind
A single-line message to show in the UI.
Definition: ClangdServer.h:324
clang::clangd::DraftStore
A thread-safe container for files opened in a workspace, addressed by filenames.
Definition: DraftStore.h:27
clang::clangd::ClangdServer::rename
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.
Definition: ClangdServer.cpp:555
clang::clangd::ClangdServer::fileStats
llvm::StringMap< TUScheduler::FileStats > fileStats() const
Returns estimated memory usage and other statistics for each of the currently open files.
Definition: ClangdServer.cpp:995
clang::clangd::BackgroundQueue::Stats
Definition: Background.h:85
XRefs.h
clang::clangd::ClangdServer::Callbacks::onSemanticsMaybeChanged
virtual void onSemanticsMaybeChanged(PathRef File)
Called when the meaning of a source code may have changed without an edit.
Definition: ClangdServer.h:86
clang::clangd::ClangdServer::featureModule
Mod * featureModule()
Gets the installed feature module of a given type, if any.
Definition: ClangdServer.h:190
clang::clangd::FeatureModuleSet::get
Mod * get()
Definition: FeatureModule.h:177
Background.h
clang::clangd::FeatureModuleSet
A FeatureModuleSet is a collection of feature modules installed in clangd.
Definition: FeatureModule.h:150
clang::clangd::getDefaultAsyncThreadsCount
unsigned getDefaultAsyncThreadsCount()
Returns a number of a default async threads to use for TUScheduler.
Definition: TUScheduler.cpp:1527
CodeComplete.h
clang::clangd::ClangdServer::Options::UpdateDebounce
DebouncePolicy UpdateDebounce
Time to wait after a new file version before computing diagnostics.
Definition: ClangdServer.h:145
clang::clangd::Path
std::string Path
A typedef to represent a file path.
Definition: Path.h:26
clang::clangd::ClangdServer::customAction
void customAction(PathRef File, llvm::StringRef Name, Callback< InputsAndAST > Action)
Runs an arbitrary action that has access to the AST of the specified file.
Definition: ClangdServer.cpp:975
clang::clangd::ASTRetentionPolicy
Configuration of the AST retention policy.
Definition: TUScheduler.h:62
Path.h
clang::clangd::ClangdServer::Options::FeatureModules
FeatureModuleSet * FeatureModules
Definition: ClangdServer.h:164
Diagnostics
WantDiagnostics Diagnostics
Definition: TUScheduler.cpp:602
clang::clangd::WantDiagnostics::Auto
@ Auto
Diagnostics must not be generated for this snapshot.
Index.h
clang::clangd::ClangdServer::findType
void findType(PathRef File, Position Pos, Callback< std::vector< LocatedSymbol >> CB)
Retrieve symbols for types referenced at Pos.
Definition: ClangdServer.cpp:846
clang::clangd::ClangdServer::getAST
void getAST(PathRef File, llvm::Optional< Range > R, Callback< llvm::Optional< ASTNode >> CB)
Describe the AST subtree for a piece of code.
Definition: ClangdServer.cpp:936
clang::clangd::ClangdServer::switchSourceHeader
void switchSourceHeader(PathRef Path, Callback< llvm::Optional< clangd::Path >> CB)
Switch to a corresponding source file when given a header file, and vice versa.
Definition: ClangdServer.cpp:705
clang::clangd::ClangdServer::findReferences
void findReferences(PathRef File, Position Pos, uint32_t Limit, Callback< ReferencesResult > CB)
Retrieve locations for symbol references.
Definition: ClangdServer.cpp:869
clang::clangd::ClangdServer::Options::ResourceDir
llvm::Optional< std::string > ResourceDir
The resource directory is used to find internal headers, overriding defaults and -resource-dir compil...
Definition: ClangdServer.h:142
ConfigProvider.h
clang::clangd::ClangdServer::Options::UseDirtyHeaders
bool UseDirtyHeaders
If true, use the dirty buffer contents when building Preambles.
Definition: ClangdServer.h:166
clang::clangd::ClangdServer::Options::PreambleParseForwardingFunctions
bool PreambleParseForwardingFunctions
Definition: ClangdServer.h:169
clang::clangd::config::Provider
A source of configuration fragments.
Definition: ConfigProvider.h:62
clang::clangd::ClangdServer::optsForTest
static Options optsForTest()
Definition: ClangdServer.cpp:154
DraftStore.h
clang::clangd::ClangdServer::Options::StorePreamblesInMemory
bool StorePreamblesInMemory
Cached preambles are potentially large. If false, store them on disk.
Definition: ClangdServer.h:105
clang::clangd::ClangdServer
Manages a collection of source files and derived data (ASTs, indexes), and provides language-aware fe...
Definition: ClangdServer.h:58
clang::clangd::ClangdServer::Callbacks::onFileUpdated
virtual void onFileUpdated(PathRef File, const TUStatus &Status)
Called whenever the file status is updated.
Definition: ClangdServer.h:73
clang::clangd::ClangdServer::Options::QueryDriverGlobs
std::vector< std::string > QueryDriverGlobs
Clangd will execute compiler drivers matching one of these globs to fetch system include path.
Definition: ClangdServer.h:159
clang::clangd::GlobalCompilationDatabase
Provides compilation arguments used for parsing C and C++ files.
Definition: GlobalCompilationDatabase.h:34
clang::clangd::ClangdServer::Options::ImplicitCancellation
bool ImplicitCancellation
Cancel certain requests if the file changes before they begin running.
Definition: ClangdServer.h:155
clang::clangd::ClangdServer::documentSymbols
void documentSymbols(StringRef File, Callback< std::vector< DocumentSymbol >> CB)
Retrieve the symbols within the specified file.
Definition: ClangdServer.cpp:822
clang::clangd::ClangdServer::foldingRanges
void foldingRanges(StringRef File, Callback< std::vector< FoldingRange >> CB)
Retrieve ranges that can be used to fold code within the specified file.
Definition: ClangdServer.cpp:834
clang::clangd::ClangdServer::findImplementations
void findImplementations(PathRef File, Position Pos, Callback< std::vector< LocatedSymbol >> CB)
Retrieve implementations for virtual method.
Definition: ClangdServer.cpp:857
clang::clangd::ClangdServer::addDocument
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.
Definition: ClangdServer.cpp:247
Pos
size_t Pos
Definition: NoLintDirectiveHandler.cpp:97
clang::clangd::ClangdServer::prepareRename
void prepareRename(PathRef File, Position Pos, llvm::Optional< std::string > NewName, const RenameOptions &RenameOpts, Callback< RenameResult > CB)
Test the validity of a rename operation.
Definition: ClangdServer.cpp:529
clang::clangd::WantDiagnostics
WantDiagnostics
Determines whether diagnostics should be generated for a file snapshot.
Definition: TUScheduler.h:52
clang::clangd::ClangdServer::TweakRef::ID
std::string ID
Definition: ClangdServer.h:322
Protocol.h
ThreadsafeFS.h
Hover.h
clang::clangd::ClangdServer::Options
Definition: ClangdServer.h:95
Rename.h
clang::clangd::Position
Definition: Protocol.h:153
clang::clangd::TUStatus
Definition: TUScheduler.h:112
clang::clangd::ClangdServer::getDraft
std::shared_ptr< const std::string > getDraft(PathRef File) const
Gets the contents of a currently tracked file.
Definition: ClangdServer.cpp:280
clang::clangd::ClangdServer::Options::StaticIndex
SymbolIndex * StaticIndex
If set, use this index to augment code completion results.
Definition: ClangdServer.h:116
clang::clangd::ClangdServer::Callbacks::~Callbacks
virtual ~Callbacks()=default
clang::clangd::ClangdServer::removeDocument
void removeDocument(PathRef File)
Remove File from list of tracked files, schedule a request to free resources associated with it.
Definition: ClangdServer.cpp:364
clang::clangd::ClangdServer::codeComplete
void codeComplete(PathRef File, Position Pos, const clangd::CodeCompleteOptions &Opts, Callback< CodeCompleteResult > CB)
Run code completion for File at Pos.
Definition: ClangdServer.cpp:369
clang::clangd::ClangdServer::Options::AsyncThreadsCount
unsigned AsyncThreadsCount
To process requests asynchronously, ClangdServer spawns worker threads.
Definition: ClangdServer.h:99
clang::clangd::ClangdServer::TweakRef::Title
std::string Title
ID to pass for applyTweak.
Definition: ClangdServer.h:323
Tweak.h
clang::clangd::MemoryTree
A tree that can be used to represent memory usage of nested components while preserving the hierarchy...
Definition: MemoryTree.h:30
GlobalCompilationDatabase.h
clang::clangd::DidChangeWatchedFilesParams
Definition: Protocol.h:756
clang::clangd::ClangdServer::inlayHints
void inlayHints(PathRef File, llvm::Optional< Range > RestrictRange, Callback< std::vector< InlayHint >>)
Resolve inlay hints for a given document.
Definition: ClangdServer.cpp:795
clang::clangd::ClangdServer::onFileEvent
void onFileEvent(const DidChangeWatchedFilesParams &Params)
Called when an event occurs for a watched file in the workspace.
Definition: ClangdServer.cpp:806
clang::clangd::ClangdServer::Options::BackgroundIndexPriority
llvm::ThreadPriority BackgroundIndexPriority
Definition: ClangdServer.h:113
clang::clangd::ClangdServer::semanticHighlights
void semanticHighlights(PathRef File, Callback< std::vector< HighlightingToken >>)
Definition: ClangdServer.cpp:924
clang::clangd::RenameOptions
Definition: Rename.h:22
clang::clangd::ClangdServer::findDocumentHighlights
void findDocumentHighlights(PathRef File, Position Pos, Callback< std::vector< DocumentHighlight >> CB)
Get document highlights for a given position.
Definition: ClangdServer.cpp:725
clang::clangd::ClangdServer::incomingCalls
void incomingCalls(const CallHierarchyItem &Item, Callback< std::vector< CallHierarchyIncomingCall >>)
Resolve incoming calls for a given call hierarchy item.
Definition: ClangdServer.cpp:786
Diagnostics.h
Name
Token Name
Definition: MacroToEnumCheck.cpp:89
clang::clangd::ClangdServer::formatOnType
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.
Definition: ClangdServer.cpp:501
clang::clangd::ClangdServer::Options::ContextProvider
std::function< Context(PathRef)> ContextProvider
If set, queried to derive a processing context for some work.
Definition: ClangdServer.h:127
FileIndex.h
clang::clangd::ClangdServer::formatFile
void formatFile(PathRef File, llvm::Optional< Range > Rng, Callback< tooling::Replacements > CB)
Run formatting for the File with content Code.
Definition: ClangdServer.cpp:463
clang::clangd::CodeCompleteOptions
Definition: CodeComplete.h:41
clang::clangd::ClangdServer::workspaceSymbols
void workspaceSymbols(StringRef Query, int Limit, Callback< std::vector< SymbolInformation >> CB)
Retrieve the top symbols from the workspace matching a query.
Definition: ClangdServer.cpp:811
clang::clangd::ClangdServer::documentLinks
void documentLinks(PathRef File, Callback< std::vector< DocumentLink >> CB)
Get all document links in a file.
Definition: ClangdServer.cpp:912
clang::clangd::ClangdServer::Options::BuildDynamicSymbolIndex
bool BuildDynamicSymbolIndex
If true, ClangdServer builds a dynamic in-memory index for symbols in opened files and uses the index...
Definition: ClangdServer.h:109
clang::clangd::SymbolIndex
Interface for symbol indexes that can be used for searching or matching symbols among a set of symbol...
Definition: Index.h:113
clang::clangd::MarkupKind
MarkupKind
Definition: Protocol.h:392
clang::clangd::ClangdServer::locateSymbolAt
void locateSymbolAt(PathRef File, Position Pos, Callback< std::vector< LocatedSymbol >> CB)
Find declaration/definition locations of symbol at a specified position.
Definition: ClangdServer.cpp:693
clang::clangd::TypeHierarchyDirection
TypeHierarchyDirection
Definition: Protocol.h:1371
clang::clangd::ClangdServer::diagnostics
void diagnostics(PathRef File, Callback< std::vector< Diag >> CB)
Fetches diagnostics for current version of the File.
Definition: ClangdServer.cpp:980
clang::clangd::TypeHierarchyItem
Definition: Protocol.h:1388
FeatureModule.h
clang::clangd::ClangdServer::Callbacks::onBackgroundIndexProgress
virtual void onBackgroundIndexProgress(const BackgroundQueue::Stats &Stats)
Called when background indexing tasks are enqueued/started/completed.
Definition: ClangdServer.h:78
ID
static char ID
Definition: Logger.cpp:74
clang::clangd::ClangdServer::Callbacks
Interface with hooks for users of ClangdServer to be notified of events.
Definition: ClangdServer.h:61
clang::clangd::PathRef
llvm::StringRef PathRef
A typedef to represent a ref to file path.
Definition: Path.h:29
clang::clangd::ThreadsafeFS
Wrapper for vfs::FileSystem for use in multithreaded programs like clangd.
Definition: ThreadsafeFS.h:27
clang::clangd::TUScheduler::ASTActionInvalidation
ASTActionInvalidation
Defines how a runWithAST action is implicitly cancelled by other actions.
Definition: TUScheduler.h:255
clang::clangd::ClangdServer::TweakRef
Definition: ClangdServer.h:321
clang::clangd::TUScheduler::Options
Definition: TUScheduler.h:186
clang::clangd::ClangdServer::applyTweak
void applyTweak(PathRef File, Range Sel, StringRef ID, Callback< Tweak::Effect > CB)
Apply the code tweak with a specified ID.
Definition: ClangdServer.cpp:646
clang::clangd::ClangdServer::signatureHelp
void signatureHelp(PathRef File, Position Pos, MarkupKind DocumentationFormat, Callback< SignatureHelp > CB)
Provide signature help for File at Pos.
Definition: ClangdServer.cpp:434
clang::clangd::Range
Definition: Protocol.h:182
clang::clangd::ClangdServer::profile
void profile(MemoryTree &MT) const
Builds a nested representation of memory used by components.
Definition: ClangdServer.cpp:1038
SemanticHighlighting.h
clang::clangd::DebouncePolicy
Clangd may wait after an update to see if another one comes along.
Definition: TUScheduler.h:73
MemoryTree.h
clang
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Definition: ApplyReplacements.h:27
clang::clangd::ClangdServer::symbolInfo
void symbolInfo(PathRef File, Position Pos, Callback< std::vector< SymbolDetails >> CB)
Get symbol info for given position.
Definition: ClangdServer.cpp:881
Function.h
TUScheduler.h
clang::clangd::ClangdServer::reparseOpenFilesIfNeeded
void reparseOpenFilesIfNeeded(llvm::function_ref< bool(llvm::StringRef File)> Filter)
Requests a reparse of currently opened files using their latest source.
Definition: ClangdServer.cpp:270
clang::clangd::Tweak
An interface base for small context-sensitive refactoring actions.
Definition: Tweak.h:46
clang::clangd::ClangdServer::Options::RetentionPolicy
ASTRetentionPolicy RetentionPolicy
AST caching policy. The default is to keep up to 3 ASTs in memory.
Definition: ClangdServer.h:102
clang::clangd::ClangdServer::semanticRanges
void semanticRanges(PathRef File, const std::vector< Position > &Pos, Callback< std::vector< SelectionRange >> CB)
Get semantic ranges around a specified position in a file.
Definition: ClangdServer.cpp:893
clang::clangd::ClangdServer::resolveTypeHierarchy
void resolveTypeHierarchy(TypeHierarchyItem Item, int Resolve, TypeHierarchyDirection Direction, Callback< llvm::Optional< TypeHierarchyItem >> CB)
Resolve type hierarchy item in the given direction.
Definition: ClangdServer.cpp:765
clang::clangd::CallHierarchyItem
Represents programming constructs like functions or constructors in the context of call hierarchy.
Definition: Protocol.h:1456
clang::clangd::ClangdServer::Options::ClangTidyProvider
TidyProviderRef ClangTidyProvider
The Options provider to use when running clang-tidy.
Definition: ClangdServer.h:131
clang::clangd::ClangdServer::findHover
void findHover(PathRef File, Position Pos, Callback< llvm::Optional< HoverInfo >> CB)
Get code hover for a given position.
Definition: ClangdServer.cpp:737
clang::clangd::Callback
llvm::unique_function< void(llvm::Expected< T >)> Callback
A Callback<T> is a void function that accepts Expected<T>.
Definition: Function.h:28
clang::clangd::ClangdServer::Options::FoldingRanges
bool FoldingRanges
Enable preview of FoldingRanges feature.
Definition: ClangdServer.h:162
clang::clangd::ClangdServer::enumerateTweaks
void enumerateTweaks(PathRef File, Range Sel, llvm::unique_function< bool(const Tweak &)> Filter, Callback< std::vector< TweakRef >> CB)
Enumerate the code tweaks available to the user at a specified point.
Definition: ClangdServer.cpp:611
clang::clangd::TidyProviderRef
llvm::function_ref< void(tidy::ClangTidyOptions &, llvm::StringRef)> TidyProviderRef
A factory to modify a tidy::ClangTidyOptions that doesn't hold any state.
Definition: TidyProvider.h:28
clang::clangd::BackgroundIndex
Definition: Background.h:133
clang::clangd::ClangdServer::Callbacks::onDiagnosticsReady
virtual void onDiagnosticsReady(PathRef File, llvm::StringRef Version, std::vector< Diag > Diagnostics)
Called by ClangdServer when Diagnostics for File are ready.
Definition: ClangdServer.h:69
clang::clangd::ClangdServer::~ClangdServer
~ClangdServer()
Definition: ClangdServer.cpp:233
clang::clangd::ClangdServer::prepareCallHierarchy
void prepareCallHierarchy(PathRef File, Position Pos, Callback< std::vector< CallHierarchyItem >> CB)
Get information about call hierarchy for a given position.
Definition: ClangdServer.cpp:775
clang::clangd::ClangdServer::ClangdServer
ClangdServer(const GlobalCompilationDatabase &CDB, const ThreadsafeFS &TFS, const Options &Opts, Callbacks *Callbacks=nullptr)
Creates a new ClangdServer instance.
Definition: ClangdServer.cpp:172
clang::clangd::Context
A context is an immutable container for per-request data that must be propagated through layers that ...
Definition: Context.h:69
clang::clangd::ClangdServer::featureModule
const Mod * featureModule() const
Definition: ClangdServer.h:193
clang::clangd::ClangdServer::typeHierarchy
void typeHierarchy(PathRef File, Position Pos, int Resolve, TypeHierarchyDirection Direction, Callback< llvm::Optional< TypeHierarchyItem >> CB)
Get information about type hierarchy for a given position.
Definition: ClangdServer.cpp:751
clang::clangd::ClangdServer::Options::WorkspaceRoot
llvm::Optional< std::string > WorkspaceRoot
Clangd's workspace root.
Definition: ClangdServer.h:136
clang::clangd::ClangdServer::blockUntilIdleForTest
LLVM_NODISCARD bool blockUntilIdleForTest(llvm::Optional< double > TimeoutSeconds=10)
Definition: ClangdServer.cpp:1000
clang::clangd::ClangdServer::createConfiguredContextProvider
static std::function< Context(PathRef)> createConfiguredContextProvider(const config::Provider *Provider, ClangdServer::Callbacks *)
Creates a context provider that loads and installs config.
Definition: ClangdServer.cpp:288
Action
FieldAction Action
Definition: MemberwiseConstructor.cpp:261