2017-05-16 17:38:59 +08:00
|
|
|
//===--- ClangdServer.h - Main clangd server code ----------------*- C++-*-===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_CLANGDSERVER_H
|
|
|
|
#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_CLANGDSERVER_H
|
|
|
|
|
2017-12-15 05:22:03 +08:00
|
|
|
#include "ClangdUnit.h"
|
|
|
|
#include "CodeComplete.h"
|
2018-01-25 22:19:21 +08:00
|
|
|
#include "CompileArgsCache.h"
|
2017-12-15 05:22:03 +08:00
|
|
|
#include "Function.h"
|
2017-05-16 17:38:59 +08:00
|
|
|
#include "GlobalCompilationDatabase.h"
|
2017-12-15 05:22:03 +08:00
|
|
|
#include "Protocol.h"
|
2018-01-31 16:51:16 +08:00
|
|
|
#include "TUScheduler.h"
|
2017-12-20 02:00:37 +08:00
|
|
|
#include "index/FileIndex.h"
|
2017-05-16 17:38:59 +08:00
|
|
|
#include "clang/Tooling/CompilationDatabase.h"
|
|
|
|
#include "clang/Tooling/Core/Replacement.h"
|
|
|
|
#include "llvm/ADT/IntrusiveRefCntPtr.h"
|
|
|
|
#include "llvm/ADT/Optional.h"
|
|
|
|
#include "llvm/ADT/StringRef.h"
|
2017-05-23 21:42:59 +08:00
|
|
|
#include <functional>
|
2018-02-09 18:17:23 +08:00
|
|
|
#include <future>
|
2017-05-16 17:38:59 +08:00
|
|
|
#include <string>
|
2017-05-30 23:11:02 +08:00
|
|
|
#include <type_traits>
|
2017-05-16 17:38:59 +08:00
|
|
|
#include <utility>
|
|
|
|
|
|
|
|
namespace clang {
|
|
|
|
class PCHContainerOperations;
|
|
|
|
|
|
|
|
namespace clangd {
|
|
|
|
|
|
|
|
class DiagnosticsConsumer {
|
|
|
|
public:
|
|
|
|
virtual ~DiagnosticsConsumer() = default;
|
|
|
|
|
|
|
|
/// Called by ClangdServer when \p Diagnostics for \p File are ready.
|
2018-03-12 23:28:22 +08:00
|
|
|
virtual void onDiagnosticsReady(PathRef File,
|
2018-03-13 07:22:35 +08:00
|
|
|
std::vector<Diag> Diagnostics) = 0;
|
2017-05-16 17:38:59 +08:00
|
|
|
};
|
|
|
|
|
2017-05-26 20:26:51 +08:00
|
|
|
class FileSystemProvider {
|
|
|
|
public:
|
|
|
|
virtual ~FileSystemProvider() = default;
|
2017-06-14 17:46:44 +08:00
|
|
|
/// Called by ClangdServer to obtain a vfs::FileSystem to be used for parsing.
|
2018-03-13 07:22:35 +08:00
|
|
|
/// Context::current() will be the context passed to the clang entrypoint,
|
|
|
|
/// such as addDocument(), and will also be propagated to result callbacks.
|
|
|
|
/// Embedders may use this to isolate filesystem accesses.
|
|
|
|
virtual IntrusiveRefCntPtr<vfs::FileSystem> getFileSystem() = 0;
|
2017-05-26 20:26:51 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
class RealFileSystemProvider : public FileSystemProvider {
|
|
|
|
public:
|
2018-03-13 07:22:35 +08:00
|
|
|
/// Returns getRealFileSystem().
|
|
|
|
IntrusiveRefCntPtr<vfs::FileSystem> getFileSystem() override;
|
2017-05-26 20:26:51 +08:00
|
|
|
};
|
|
|
|
|
2017-05-16 17:38:59 +08:00
|
|
|
/// Provides API to manage ASTs for a collection of C++ files and request
|
2017-08-22 17:16:46 +08:00
|
|
|
/// various language features.
|
|
|
|
/// Currently supports async diagnostics, code completion, formatting and goto
|
|
|
|
/// definition.
|
2017-05-16 17:38:59 +08:00
|
|
|
class ClangdServer {
|
|
|
|
public:
|
2018-03-06 01:28:54 +08:00
|
|
|
struct Options {
|
|
|
|
/// To process requests asynchronously, ClangdServer spawns worker threads.
|
|
|
|
/// If 0, all requests are processed on the calling thread.
|
|
|
|
unsigned AsyncThreadsCount = getDefaultAsyncThreadsCount();
|
|
|
|
|
|
|
|
/// Cached preambles are potentially large. If false, store them on disk.
|
|
|
|
bool StorePreamblesInMemory = true;
|
|
|
|
|
|
|
|
/// If true, ClangdServer builds a dynamic in-memory index for symbols in
|
|
|
|
/// opened files and uses the index to augment code completion results.
|
|
|
|
bool BuildDynamicSymbolIndex = false;
|
|
|
|
|
|
|
|
/// If set, use this index to augment code completion results.
|
|
|
|
SymbolIndex *StaticIndex = nullptr;
|
|
|
|
|
|
|
|
/// The resource directory is used to find internal headers, overriding
|
|
|
|
/// defaults and -resource-dir compiler flag).
|
|
|
|
/// If None, ClangdServer calls CompilerInvocation::GetResourcePath() to
|
|
|
|
/// obtain the standard resource directory.
|
|
|
|
llvm::Optional<StringRef> ResourceDir = llvm::None;
|
|
|
|
|
|
|
|
/// Time to wait after a new file version before computing diagnostics.
|
|
|
|
std::chrono::steady_clock::duration UpdateDebounce =
|
|
|
|
std::chrono::milliseconds(500);
|
|
|
|
};
|
|
|
|
// Sensible default options for use in tests.
|
|
|
|
// Features like indexing must be enabled if desired.
|
|
|
|
static Options optsForTest();
|
|
|
|
|
2017-08-22 17:16:46 +08:00
|
|
|
/// Creates a new ClangdServer instance.
|
|
|
|
///
|
|
|
|
/// ClangdServer uses \p CDB to obtain compilation arguments for parsing. Note
|
|
|
|
/// that ClangdServer only obtains compilation arguments once for each newly
|
|
|
|
/// added file (i.e., when processing a first call to addDocument) and reuses
|
|
|
|
/// those arguments for subsequent reparses. However, ClangdServer will check
|
|
|
|
/// if compilation arguments changed on calls to forceReparse().
|
|
|
|
///
|
|
|
|
/// After each parsing request finishes, ClangdServer reports diagnostics to
|
|
|
|
/// \p DiagConsumer. Note that a callback to \p DiagConsumer happens on a
|
|
|
|
/// worker thread. Therefore, instances of \p DiagConsumer must properly
|
|
|
|
/// synchronize access to shared state.
|
2018-03-06 01:28:54 +08:00
|
|
|
ClangdServer(GlobalCompilationDatabase &CDB, FileSystemProvider &FSProvider,
|
|
|
|
DiagnosticsConsumer &DiagConsumer, const Options &Opts);
|
2017-05-16 17:38:59 +08:00
|
|
|
|
2017-09-27 23:31:17 +08:00
|
|
|
/// Set the root path of the workspace.
|
|
|
|
void setRootPath(PathRef RootPath);
|
|
|
|
|
2017-05-16 17:38:59 +08:00
|
|
|
/// Add a \p File to the list of tracked C++ files or update the contents if
|
|
|
|
/// \p File is already tracked. Also schedules parsing of the AST for it on a
|
|
|
|
/// separate thread. When the parsing is complete, DiagConsumer passed in
|
|
|
|
/// constructor will receive onDiagnosticsReady callback.
|
2018-03-15 01:08:41 +08:00
|
|
|
/// When \p SkipCache is true, compile commands will always be requested from
|
|
|
|
/// compilation database even if they were cached in previous invocations.
|
2018-02-22 21:11:12 +08:00
|
|
|
void addDocument(PathRef File, StringRef Contents,
|
2018-03-15 01:08:41 +08:00
|
|
|
WantDiagnostics WD = WantDiagnostics::Auto,
|
|
|
|
bool SkipCache = false);
|
[clangd] Pass Context implicitly using TLS.
Summary:
Instead of passing Context explicitly around, we now have a thread-local
Context object `Context::current()` which is an implicit argument to
every function.
Most manipulation of this should use the WithContextValue helper, which
augments the current Context to add a single KV pair, and restores the
old context on destruction.
Advantages are:
- less boilerplate in functions that just propagate contexts
- reading most code doesn't require understanding context at all, and
using context as values in fewer places still
- fewer options to pass the "wrong" context when it changes within a
scope (e.g. when using Span)
- contexts pass through interfaces we can't modify, such as VFS
- propagating contexts across threads was slightly tricky (e.g.
copy vs move, no move-init in lambdas), and is now encapsulated in
the threadpool
Disadvantages are all the usual TLS stuff - hidden magic, and
potential for higher memory usage on threads that don't use the
context. (In practice, it's just one pointer)
Reviewers: ilya-biryukov
Subscribers: klimek, jkorous-apple, ioeric, cfe-commits
Differential Revision: https://reviews.llvm.org/D42517
llvm-svn: 323872
2018-01-31 21:40:48 +08:00
|
|
|
|
2017-05-16 17:38:59 +08:00
|
|
|
/// Remove \p File from list of tracked files, schedule a request to free
|
|
|
|
/// resources associated with it.
|
2018-02-08 15:37:35 +08:00
|
|
|
void removeDocument(PathRef File);
|
[clangd] Pass Context implicitly using TLS.
Summary:
Instead of passing Context explicitly around, we now have a thread-local
Context object `Context::current()` which is an implicit argument to
every function.
Most manipulation of this should use the WithContextValue helper, which
augments the current Context to add a single KV pair, and restores the
old context on destruction.
Advantages are:
- less boilerplate in functions that just propagate contexts
- reading most code doesn't require understanding context at all, and
using context as values in fewer places still
- fewer options to pass the "wrong" context when it changes within a
scope (e.g. when using Span)
- contexts pass through interfaces we can't modify, such as VFS
- propagating contexts across threads was slightly tricky (e.g.
copy vs move, no move-init in lambdas), and is now encapsulated in
the threadpool
Disadvantages are all the usual TLS stuff - hidden magic, and
potential for higher memory usage on threads that don't use the
context. (In practice, it's just one pointer)
Reviewers: ilya-biryukov
Subscribers: klimek, jkorous-apple, ioeric, cfe-commits
Differential Revision: https://reviews.llvm.org/D42517
llvm-svn: 323872
2018-01-31 21:40:48 +08:00
|
|
|
|
2017-10-06 01:04:13 +08:00
|
|
|
/// Run code completion for \p File at \p Pos.
|
[clangd] Pass Context implicitly using TLS.
Summary:
Instead of passing Context explicitly around, we now have a thread-local
Context object `Context::current()` which is an implicit argument to
every function.
Most manipulation of this should use the WithContextValue helper, which
augments the current Context to add a single KV pair, and restores the
old context on destruction.
Advantages are:
- less boilerplate in functions that just propagate contexts
- reading most code doesn't require understanding context at all, and
using context as values in fewer places still
- fewer options to pass the "wrong" context when it changes within a
scope (e.g. when using Span)
- contexts pass through interfaces we can't modify, such as VFS
- propagating contexts across threads was slightly tricky (e.g.
copy vs move, no move-init in lambdas), and is now encapsulated in
the threadpool
Disadvantages are all the usual TLS stuff - hidden magic, and
potential for higher memory usage on threads that don't use the
context. (In practice, it's just one pointer)
Reviewers: ilya-biryukov
Subscribers: klimek, jkorous-apple, ioeric, cfe-commits
Differential Revision: https://reviews.llvm.org/D42517
llvm-svn: 323872
2018-01-31 21:40:48 +08:00
|
|
|
/// Request is processed asynchronously.
|
2017-10-06 01:04:13 +08:00
|
|
|
///
|
|
|
|
/// This method should only be called for currently tracked files. However, it
|
|
|
|
/// is safe to call removeDocument for \p File after this method returns, even
|
|
|
|
/// while returned future is not yet ready.
|
2017-10-25 17:35:10 +08:00
|
|
|
/// A version of `codeComplete` that runs \p Callback on the processing thread
|
|
|
|
/// when codeComplete results become available.
|
[clangd] Pass Context implicitly using TLS.
Summary:
Instead of passing Context explicitly around, we now have a thread-local
Context object `Context::current()` which is an implicit argument to
every function.
Most manipulation of this should use the WithContextValue helper, which
augments the current Context to add a single KV pair, and restores the
old context on destruction.
Advantages are:
- less boilerplate in functions that just propagate contexts
- reading most code doesn't require understanding context at all, and
using context as values in fewer places still
- fewer options to pass the "wrong" context when it changes within a
scope (e.g. when using Span)
- contexts pass through interfaces we can't modify, such as VFS
- propagating contexts across threads was slightly tricky (e.g.
copy vs move, no move-init in lambdas), and is now encapsulated in
the threadpool
Disadvantages are all the usual TLS stuff - hidden magic, and
potential for higher memory usage on threads that don't use the
context. (In practice, it's just one pointer)
Reviewers: ilya-biryukov
Subscribers: klimek, jkorous-apple, ioeric, cfe-commits
Differential Revision: https://reviews.llvm.org/D42517
llvm-svn: 323872
2018-01-31 21:40:48 +08:00
|
|
|
void codeComplete(PathRef File, Position Pos,
|
|
|
|
const clangd::CodeCompleteOptions &Opts,
|
2018-03-13 07:22:35 +08:00
|
|
|
Callback<CompletionList> CB);
|
[clangd] Pass Context implicitly using TLS.
Summary:
Instead of passing Context explicitly around, we now have a thread-local
Context object `Context::current()` which is an implicit argument to
every function.
Most manipulation of this should use the WithContextValue helper, which
augments the current Context to add a single KV pair, and restores the
old context on destruction.
Advantages are:
- less boilerplate in functions that just propagate contexts
- reading most code doesn't require understanding context at all, and
using context as values in fewer places still
- fewer options to pass the "wrong" context when it changes within a
scope (e.g. when using Span)
- contexts pass through interfaces we can't modify, such as VFS
- propagating contexts across threads was slightly tricky (e.g.
copy vs move, no move-init in lambdas), and is now encapsulated in
the threadpool
Disadvantages are all the usual TLS stuff - hidden magic, and
potential for higher memory usage on threads that don't use the
context. (In practice, it's just one pointer)
Reviewers: ilya-biryukov
Subscribers: klimek, jkorous-apple, ioeric, cfe-commits
Differential Revision: https://reviews.llvm.org/D42517
llvm-svn: 323872
2018-01-31 21:40:48 +08:00
|
|
|
|
2018-03-16 22:30:42 +08:00
|
|
|
/// Provide signature help for \p File at \p Pos. This method should only be
|
|
|
|
/// called for tracked files.
|
2018-03-13 07:22:35 +08:00
|
|
|
void signatureHelp(PathRef File, Position Pos, Callback<SignatureHelp> CB);
|
2017-10-06 19:54:17 +08:00
|
|
|
|
2017-06-29 00:12:10 +08:00
|
|
|
/// Get definition of symbol at a specified \p Line and \p Column in \p File.
|
2018-03-13 07:22:35 +08:00
|
|
|
void findDefinitions(PathRef File, Position Pos,
|
|
|
|
Callback<std::vector<Location>> CB);
|
2017-05-16 17:38:59 +08:00
|
|
|
|
2017-09-28 11:14:40 +08:00
|
|
|
/// Helper function that returns a path to the corresponding source file when
|
|
|
|
/// given a header file and vice versa.
|
|
|
|
llvm::Optional<Path> switchSourceHeader(PathRef Path);
|
|
|
|
|
[clangd] Document highlights for clangd
Summary: Implementation of Document Highlights Request as described in
LSP.
Contributed by William Enright (nebiroth).
Reviewers: malaperle, krasimir, bkramer, ilya-biryukov
Reviewed By: malaperle
Subscribers: mgrang, sammccall, klimek, ioeric, rwols, cfe-commits, arphaman, ilya-biryukov
Differential Revision: https://reviews.llvm.org/D38425
llvm-svn: 320474
2017-12-12 20:27:47 +08:00
|
|
|
/// Get document highlights for a given position.
|
2018-03-13 07:22:35 +08:00
|
|
|
void findDocumentHighlights(PathRef File, Position Pos,
|
|
|
|
Callback<std::vector<DocumentHighlight>> CB);
|
[clangd] Document highlights for clangd
Summary: Implementation of Document Highlights Request as described in
LSP.
Contributed by William Enright (nebiroth).
Reviewers: malaperle, krasimir, bkramer, ilya-biryukov
Reviewed By: malaperle
Subscribers: mgrang, sammccall, klimek, ioeric, rwols, cfe-commits, arphaman, ilya-biryukov
Differential Revision: https://reviews.llvm.org/D38425
llvm-svn: 320474
2017-12-12 20:27:47 +08:00
|
|
|
|
[clangd] Implement textDocument/hover
Summary: Implemention of textDocument/hover as described in LSP definition.
This patch adds a basic Hover implementation. When hovering a variable,
function, method or namespace, clangd will return a text containing the
declaration's scope, as well as the declaration of the hovered entity.
For example, for a variable:
Declared in class Foo::Bar
int hello = 2
For macros, the macro definition is returned.
This patch doesn't include:
- markdown support (the client I use doesn't support it yet)
- range support (optional in the Hover response)
- comments associated to variables/functions/classes
They are kept as future work to keep this patch simpler.
I added tests in XRefsTests.cpp. hover.test contains one simple
smoketest to make sure the feature works from a black box perspective.
Reviewers: malaperle, krasimir, bkramer, ilya-biryukov
Subscribers: sammccall, mgrang, klimek, rwols, ilya-biryukov, arphaman, cfe-commits
Differential Revision: https://reviews.llvm.org/D35894
Signed-off-by: Simon Marchi <simon.marchi@ericsson.com>
Signed-off-by: William Enright <william.enright@polymtl.ca>
llvm-svn: 325395
2018-02-17 05:38:15 +08:00
|
|
|
/// Get code hover for a given position.
|
2018-03-13 07:22:35 +08:00
|
|
|
void findHover(PathRef File, Position Pos, Callback<Hover> CB);
|
[clangd] Implement textDocument/hover
Summary: Implemention of textDocument/hover as described in LSP definition.
This patch adds a basic Hover implementation. When hovering a variable,
function, method or namespace, clangd will return a text containing the
declaration's scope, as well as the declaration of the hovered entity.
For example, for a variable:
Declared in class Foo::Bar
int hello = 2
For macros, the macro definition is returned.
This patch doesn't include:
- markdown support (the client I use doesn't support it yet)
- range support (optional in the Hover response)
- comments associated to variables/functions/classes
They are kept as future work to keep this patch simpler.
I added tests in XRefsTests.cpp. hover.test contains one simple
smoketest to make sure the feature works from a black box perspective.
Reviewers: malaperle, krasimir, bkramer, ilya-biryukov
Subscribers: sammccall, mgrang, klimek, rwols, ilya-biryukov, arphaman, cfe-commits
Differential Revision: https://reviews.llvm.org/D35894
Signed-off-by: Simon Marchi <simon.marchi@ericsson.com>
Signed-off-by: William Enright <william.enright@polymtl.ca>
llvm-svn: 325395
2018-02-17 05:38:15 +08:00
|
|
|
|
[clangd] Implementation of workspace/symbol request
Summary:
This is a basic implementation of the "workspace/symbol" request which is
used to find symbols by a string query. Since this is similar to code completion
in terms of result, this implementation reuses the "fuzzyFind" in order to get
matches. For now, the scoring algorithm is the same as code completion and
improvements could be done in the future.
The index model doesn't contain quite enough symbols for this to cover
common symbols like methods, enum class enumerators, functions in unamed
namespaces, etc. The index model will be augmented separately to achieve this.
Reviewers: sammccall, ilya-biryukov
Reviewed By: sammccall
Subscribers: jkorous, hokein, simark, sammccall, klimek, mgorny, ilya-biryukov, mgrang, jkorous-apple, ioeric, MaskRay, cfe-commits
Differential Revision: https://reviews.llvm.org/D44882
llvm-svn: 330637
2018-04-24 04:00:52 +08:00
|
|
|
/// Retrieve the top symbols from the workspace matching a query.
|
|
|
|
void workspaceSymbols(StringRef Query, int Limit,
|
|
|
|
Callback<std::vector<SymbolInformation>> CB);
|
|
|
|
|
2017-12-13 04:25:06 +08:00
|
|
|
/// Run formatting for \p Rng inside \p File with content \p Code.
|
|
|
|
llvm::Expected<tooling::Replacements> formatRange(StringRef Code,
|
|
|
|
PathRef File, Range Rng);
|
|
|
|
|
|
|
|
/// Run formatting for the whole \p File with content \p Code.
|
|
|
|
llvm::Expected<tooling::Replacements> formatFile(StringRef Code,
|
|
|
|
PathRef File);
|
|
|
|
|
|
|
|
/// Run formatting after a character was typed at \p Pos in \p File with
|
|
|
|
/// content \p Code.
|
|
|
|
llvm::Expected<tooling::Replacements>
|
|
|
|
formatOnType(StringRef Code, PathRef File, Position Pos);
|
|
|
|
|
2017-11-09 19:30:04 +08:00
|
|
|
/// Rename all occurrences of the symbol at the \p Pos in \p File to
|
|
|
|
/// \p NewName.
|
2018-02-15 21:15:47 +08:00
|
|
|
void rename(PathRef File, Position Pos, llvm::StringRef NewName,
|
2018-03-13 07:22:35 +08:00
|
|
|
Callback<std::vector<tooling::Replacement>> CB);
|
2017-05-16 22:40:30 +08:00
|
|
|
|
2017-05-23 21:42:59 +08:00
|
|
|
/// Only for testing purposes.
|
|
|
|
/// Waits until all requests to worker thread are finished and dumps AST for
|
|
|
|
/// \p File. \p File must be in the list of added documents.
|
2018-02-15 21:15:47 +08:00
|
|
|
void dumpAST(PathRef File, UniqueFunction<void(std::string)> Callback);
|
2017-10-03 02:00:37 +08:00
|
|
|
/// Called when an event occurs for a watched file in the workspace.
|
|
|
|
void onFileEvent(const DidChangeWatchedFilesParams &Params);
|
2017-05-16 17:38:59 +08:00
|
|
|
|
2018-01-25 22:32:21 +08:00
|
|
|
/// Returns estimated memory usage for each of the currently open files.
|
|
|
|
/// The order of results is unspecified.
|
|
|
|
/// Overall memory usage of clangd may be significantly more than reported
|
|
|
|
/// here, as this metric does not account (at least) for:
|
|
|
|
/// - memory occupied by static and dynamic index,
|
|
|
|
/// - memory required for in-flight requests,
|
|
|
|
/// FIXME: those metrics might be useful too, we should add them.
|
|
|
|
std::vector<std::pair<Path, std::size_t>> getUsedBytesPerFile() const;
|
|
|
|
|
2018-02-13 16:59:23 +08:00
|
|
|
// Blocks the main thread until the server is idle. Only for use in tests.
|
|
|
|
// Returns false if the timeout expires.
|
|
|
|
LLVM_NODISCARD bool
|
|
|
|
blockUntilIdleForTest(llvm::Optional<double> TimeoutSeconds = 10);
|
|
|
|
|
2017-05-23 21:42:59 +08:00
|
|
|
private:
|
2017-12-13 04:25:06 +08:00
|
|
|
/// FIXME: This stats several files to find a .clang-format file. I/O can be
|
|
|
|
/// slow. Think of a way to cache this.
|
|
|
|
llvm::Expected<tooling::Replacements>
|
|
|
|
formatCode(llvm::StringRef Code, PathRef File,
|
|
|
|
ArrayRef<tooling::Range> Ranges);
|
|
|
|
|
2018-03-16 22:30:42 +08:00
|
|
|
typedef uint64_t DocVersion;
|
|
|
|
|
2018-03-15 01:08:41 +08:00
|
|
|
void consumeDiagnostics(PathRef File, DocVersion Version,
|
|
|
|
std::vector<Diag> Diags);
|
2017-08-14 16:17:24 +08:00
|
|
|
|
2018-01-25 22:19:21 +08:00
|
|
|
CompileArgsCache CompileArgs;
|
2017-06-13 23:59:43 +08:00
|
|
|
DiagnosticsConsumer &DiagConsumer;
|
|
|
|
FileSystemProvider &FSProvider;
|
2018-03-16 22:30:42 +08:00
|
|
|
|
|
|
|
/// Used to synchronize diagnostic responses for added and removed files.
|
|
|
|
llvm::StringMap<DocVersion> InternalVersion;
|
|
|
|
|
2018-01-15 20:33:00 +08:00
|
|
|
// The index used to look up symbols. This could be:
|
|
|
|
// - null (all index functionality is optional)
|
|
|
|
// - the dynamic index owned by ClangdServer (FileIdx)
|
|
|
|
// - the static index passed to the constructor
|
|
|
|
// - a merged view of a static and dynamic index (MergedIndex)
|
|
|
|
SymbolIndex *Index;
|
|
|
|
// If present, an up-to-date of symbols in open files. Read via Index.
|
2017-12-20 02:00:37 +08:00
|
|
|
std::unique_ptr<FileIndex> FileIdx;
|
2018-01-15 20:33:00 +08:00
|
|
|
// If present, a merged view of FileIdx and an external index. Read via Index.
|
|
|
|
std::unique_ptr<SymbolIndex> MergedIndex;
|
2017-09-27 23:31:17 +08:00
|
|
|
// If set, this represents the workspace path.
|
|
|
|
llvm::Optional<std::string> RootPath;
|
2017-05-16 17:38:59 +08:00
|
|
|
std::shared_ptr<PCHContainerOperations> PCHs;
|
2017-09-20 20:58:55 +08:00
|
|
|
/// Used to serialize diagnostic callbacks.
|
|
|
|
/// FIXME(ibiryukov): get rid of an extra map and put all version counters
|
|
|
|
/// into CppFile.
|
|
|
|
std::mutex DiagnosticsMutex;
|
|
|
|
/// Maps from a filename to the latest version of reported diagnostics.
|
|
|
|
llvm::StringMap<DocVersion> ReportedDiagnosticVersions;
|
2017-09-21 03:32:06 +08:00
|
|
|
// WorkScheduler has to be the last member, because its destructor has to be
|
|
|
|
// called before all other members to stop the worker thread that references
|
2018-01-31 16:51:16 +08:00
|
|
|
// ClangdServer.
|
|
|
|
TUScheduler WorkScheduler;
|
2017-05-16 17:38:59 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
} // namespace clangd
|
|
|
|
} // namespace clang
|
|
|
|
|
|
|
|
#endif
|