2017-02-07 18:28:20 +08:00
|
|
|
//===--- ProtocolHandlers.h - LSP callbacks ---------------------*- C++ -*-===//
|
|
|
|
|
//
|
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
|
//
|
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
|
//
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
//
|
2017-10-12 21:29:58 +08:00
|
|
|
// ProtocolHandlers translates incoming JSON requests from JSONRPCDispatcher
|
|
|
|
|
// into method calls on ClangLSPServer.
|
|
|
|
|
//
|
|
|
|
|
// Currently it parses requests into objects, but the ClangLSPServer is
|
|
|
|
|
// responsible for producing JSON responses. We should move that here, too.
|
2017-02-07 18:28:20 +08:00
|
|
|
//
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
|
|
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_PROTOCOLHANDLERS_H
|
|
|
|
|
#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_PROTOCOLHANDLERS_H
|
|
|
|
|
|
|
|
|
|
#include "JSONRPCDispatcher.h"
|
|
|
|
|
#include "Protocol.h"
|
|
|
|
|
#include "llvm/ADT/Twine.h"
|
|
|
|
|
#include "llvm/Support/raw_ostream.h"
|
|
|
|
|
|
|
|
|
|
namespace clang {
|
|
|
|
|
namespace clangd {
|
|
|
|
|
|
2017-10-12 21:29:58 +08:00
|
|
|
// The interface implemented by ClangLSPServer to handle incoming requests.
|
2017-05-16 22:40:30 +08:00
|
|
|
class ProtocolCallbacks {
|
|
|
|
|
public:
|
|
|
|
|
virtual ~ProtocolCallbacks() = default;
|
|
|
|
|
|
[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
|
|
|
virtual void onInitialize(InitializeParams &Params) = 0;
|
|
|
|
|
virtual void onShutdown(ShutdownParams &Params) = 0;
|
|
|
|
|
virtual void onExit(ExitParams &Params) = 0;
|
|
|
|
|
virtual void onDocumentDidOpen(DidOpenTextDocumentParams &Params) = 0;
|
|
|
|
|
virtual void onDocumentDidChange(DidChangeTextDocumentParams &Params) = 0;
|
|
|
|
|
virtual void onDocumentDidClose(DidCloseTextDocumentParams &Params) = 0;
|
|
|
|
|
virtual void onDocumentFormatting(DocumentFormattingParams &Params) = 0;
|
2017-10-12 21:29:58 +08:00
|
|
|
virtual void
|
[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
|
|
|
onDocumentOnTypeFormatting(DocumentOnTypeFormattingParams &Params) = 0;
|
2017-10-12 21:29:58 +08:00
|
|
|
virtual void
|
[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
|
|
|
onDocumentRangeFormatting(DocumentRangeFormattingParams &Params) = 0;
|
|
|
|
|
virtual void onCodeAction(CodeActionParams &Params) = 0;
|
|
|
|
|
virtual void onCompletion(TextDocumentPositionParams &Params) = 0;
|
|
|
|
|
virtual void onSignatureHelp(TextDocumentPositionParams &Params) = 0;
|
|
|
|
|
virtual void onGoToDefinition(TextDocumentPositionParams &Params) = 0;
|
|
|
|
|
virtual void onSwitchSourceHeader(TextDocumentIdentifier &Params) = 0;
|
|
|
|
|
virtual void onFileEvent(DidChangeWatchedFilesParams &Params) = 0;
|
|
|
|
|
virtual void onCommand(ExecuteCommandParams &Params) = 0;
|
[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
|
|
|
virtual void onWorkspaceSymbol(WorkspaceSymbolParams &Params) = 0;
|
[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
|
|
|
virtual void onRename(RenameParams &Parames) = 0;
|
|
|
|
|
virtual void onDocumentHighlight(TextDocumentPositionParams &Params) = 0;
|
[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
|
|
|
virtual void onHover(TextDocumentPositionParams &Params) = 0;
|
[clangd] DidChangeConfiguration Notification
Summary:
Implementation of DidChangeConfiguration notification handling in
clangd. This currently only supports changing one setting: the path of
the compilation database to be used for the current project. In other
words, it is no longer necessary to restart clangd with a different
command line argument in order to change the compilation database.
Reviewers: malaperle, krasimir, bkramer, ilya-biryukov
Subscribers: jkorous-apple, ioeric, simark, klimek, ilya-biryukov, arphaman, rwols, cfe-commits
Differential Revision: https://reviews.llvm.org/D39571
Signed-off-by: Simon Marchi <simon.marchi@ericsson.com>
Signed-off-by: William Enright <william.enright@polymtl.ca>
llvm-svn: 325784
2018-02-22 22:00:39 +08:00
|
|
|
virtual void onChangeConfiguration(DidChangeConfigurationParams &Params) = 0;
|
2017-05-16 22:40:30 +08:00
|
|
|
};
|
|
|
|
|
|
2018-03-08 05:47:25 +08:00
|
|
|
void registerCallbackHandlers(JSONRPCDispatcher &Dispatcher,
|
2017-10-02 23:10:41 +08:00
|
|
|
ProtocolCallbacks &Callbacks);
|
2017-04-04 17:46:39 +08:00
|
|
|
|
2017-02-07 18:28:20 +08:00
|
|
|
} // namespace clangd
|
|
|
|
|
} // namespace clang
|
|
|
|
|
|
|
|
|
|
#endif
|