Zengtudor/ccls
1
0
Fork 0
mirror of https://github.com/MaskRay/ccls.git synced 2024-11-24 00:25:07 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Remove global list of message ids.

Browse Source 
Also do some naming cleanup. Also remove xmacros.
This commit is contained in:
Jacob Dufault 2018-03-21 21:05:25 -07:00
parent 5f085729bd
commit cad6dcda0c
50 changed files with 517 additions and 550 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

67
src/command_line.cc
View File

@ -57,20 +57,15 @@ namespace {
std::vector<std::string> kEmptyArgs; std::vector<std::string> kEmptyArgs;
// This function returns true if e2e timing should be displayed for the given // This function returns true if e2e timing should be displayed for the given
// IpcId. // MethodId.
bool ShouldDisplayIpcTiming(IpcId id) { bool ShouldDisplayMethodTiming(MethodType type) {
switch (id) { return
case IpcId::TextDocumentPublishDiagnostics: type != kMethodType_TextDocumentPublishDiagnostics &&
case IpcId::CqueryPublishInactiveRegions: type != kMethodType_CqueryPublishInactiveRegions &&
case IpcId::Unknown: type != kMethodType_Unknown;
return false;
default:
return true; return true;
}
} }
REGISTER_IPC_MESSAGE(Ipc_CancelRequest);
void PrintHelp() { void PrintHelp() {
std::cout std::cout
<< R"help(cquery is a low-latency C/C++/Objective-C language server. << R"help(cquery is a low-latency C/C++/Objective-C language server.
@ -146,16 +141,16 @@ bool QueryDbMainLoop(Config* config,
queue->for_querydb.DequeueAll(); queue->for_querydb.DequeueAll();
bool did_work = messages.size(); bool did_work = messages.size();
for (auto& message : messages) { for (auto& message : messages) {
// TODO: Consider using std::unordered_map to lookup the handler
for (MessageHandler* handler : *MessageHandler::message_handlers) { for (MessageHandler* handler : *MessageHandler::message_handlers) {
if (handler->GetId() == message->method_id) { if (handler->GetMethodType() == message->GetMethodType()) {
handler->Run(std::move(message)); handler->Run(std::move(message));
break; break;
} }
} }
if (message) { if (message) {
LOG_S(FATAL) << "Exiting; unhandled IPC message " LOG_S(FATAL) << "Exiting; no handler for " << message->GetMethodType();
<< IpcIdToString(message->method_id);
exit(1); exit(1);
} }
} }
@ -199,7 +194,7 @@ void RunQueryDbThread(const std::string& bin_name,
out.error.message = out.error.message =
"Dropping completion request; a newer request " "Dropping completion request; a newer request "
"has come in that will be serviced instead."; "has come in that will be serviced instead.";
QueueManager::WriteStdout(IpcId::Unknown, out); QueueManager::WriteStdout(kMethodType_Unknown, out);
} }
}); });
@ -278,7 +273,7 @@ void RunQueryDbThread(const std::string& bin_name,
// //
// |ipc| is connected to a server. // |ipc| is connected to a server.
void LaunchStdinLoop(Config* config, void LaunchStdinLoop(Config* config,
std::unordered_map<IpcId, Timer>* request_times) { std::unordered_map<MethodType, Timer>* request_times) {
// If flushing cin requires flushing cout there could be deadlocks in some // If flushing cin requires flushing cout there could be deadlocks in some
// clients. // clients.
std::cin.tie(nullptr); std::cin.tie(nullptr);
@ -301,47 +296,28 @@ void LaunchStdinLoop(Config* config,
out.id = id; out.id = id;
out.error.code = lsErrorCodes::InvalidParams; out.error.code = lsErrorCodes::InvalidParams;
out.error.message = std::move(*err); out.error.message = std::move(*err);
queue->WriteStdout(IpcId::Unknown, out); queue->WriteStdout(kMethodType_Unknown, out);
} }
} }
continue; continue;
} }
// Cache |method_id| so we can access it after moving |message|. // Cache |method_id| so we can access it after moving |message|.
IpcId method_id = message->method_id; MethodType method_type = message->GetMethodType();
(*request_times)[method_id] = Timer(); (*request_times)[method_type] = Timer();
switch (method_id) { LOG_S(ERROR) << "!! Got message of type " << method_type;
case IpcId::Initialized: {
// TODO: don't send output until we get this notification
break;
}
case IpcId::CancelRequest: {
// TODO: support cancellation
break;
}
case IpcId::Exit:
#define CASE(name, method) case IpcId::name:
#include "methods.inc"
#undef CASE
queue->for_querydb.PushBack(std::move(message)); queue->for_querydb.PushBack(std::move(message));
break;
case IpcId::Unknown:
break;
}
// If the message was to exit then querydb will take care of the actual // If the message was to exit then querydb will take care of the actual
// exit. Stop reading from stdin since it might be detached. // exit. Stop reading from stdin since it might be detached.
if (method_id == IpcId::Exit) if (method_type == kMethodType_Exit)
break; break;
} }
}); });
} }
void LaunchStdoutThread(std::unordered_map<IpcId, Timer>* request_times, void LaunchStdoutThread(std::unordered_map<MethodType, Timer>* request_times,
MultiQueueWaiter* waiter) { MultiQueueWaiter* waiter) {
WorkThread::StartThread("stdout", [=]() { WorkThread::StartThread("stdout", [=]() {
auto* queue = QueueManager::instance(); auto* queue = QueueManager::instance();
@ -354,10 +330,9 @@ void LaunchStdoutThread(std::unordered_map<IpcId, Timer>* request_times,
} }
for (auto& message : messages) { for (auto& message : messages) {
if (ShouldDisplayIpcTiming(message.id)) { if (ShouldDisplayMethodTiming(message.method)) {
Timer time = (*request_times)[message.id]; Timer time = (*request_times)[message.method];
time.ResetAndPrint("[e2e] Running " + time.ResetAndPrint("[e2e] Running " + std::string(message.method));
std::string(IpcIdToString(message.id)));
} }
RecordOutput(message.content); RecordOutput(message.content);
@ -374,7 +349,7 @@ void LanguageServerMain(const std::string& bin_name,
MultiQueueWaiter* querydb_waiter, MultiQueueWaiter* querydb_waiter,
MultiQueueWaiter* indexer_waiter, MultiQueueWaiter* indexer_waiter,
MultiQueueWaiter* stdout_waiter) { MultiQueueWaiter* stdout_waiter) {
std::unordered_map<IpcId, Timer> request_times; std::unordered_map<MethodType, Timer> request_times;
LaunchStdinLoop(config, &request_times); LaunchStdinLoop(config, &request_times);

2
src/diagnostics_engine.cc
View File

@ -30,6 +30,6 @@ void DiagnosticsEngine::Publish(WorkingFiles* working_files,
Out_TextDocumentPublishDiagnostics out; Out_TextDocumentPublishDiagnostics out;
out.params.uri = lsDocumentUri::FromPath(path); out.params.uri = lsDocumentUri::FromPath(path);
out.params.diagnostics = diagnostics; out.params.diagnostics = diagnostics;
QueueManager::WriteStdout(IpcId::TextDocumentPublishDiagnostics, out); QueueManager::WriteStdout(kMethodType_TextDocumentPublishDiagnostics, out);
} }
} }

4
src/import_pipeline.cc
View File

@ -136,7 +136,7 @@ struct ActiveThread {
GetCurrentTimeInMilliseconds() + config_->progressReportFrequencyMs; GetCurrentTimeInMilliseconds() + config_->progressReportFrequencyMs;
} }
QueueManager::WriteStdout(IpcId::Unknown, out); QueueManager::WriteStdout(kMethodType_Unknown, out);
} }
Config* config_; Config* config_;
@ -400,7 +400,7 @@ void ParseFile(Config* config,
out.id = request.id; out.id = request.id;
out.error.code = lsErrorCodes::InternalError; out.error.code = lsErrorCodes::InternalError;
out.error.message = "Failed to index " + path_to_index; out.error.message = "Failed to index " + path_to_index;
QueueManager::WriteStdout(IpcId::Unknown, out); QueueManager::WriteStdout(kMethodType_Unknown, out);
} }
return; return;
} }

30
src/ipc.cc
View File

@ -1,30 +1,10 @@
#include "ipc.h" #include "ipc.h"
#include <cassert> const char* kMethodType_Unknown = "$unknown";
const char* kMethodType_Exit = "exit";
const char* IpcIdToString(IpcId id) { const char* kMethodType_TextDocumentPublishDiagnostics = "textDocument/publishDiagnostics";
switch (id) { const char* kMethodType_CqueryPublishInactiveRegions = "$cquery/publishInactiveRegions";
case IpcId::CancelRequest: const char* kMethodType_CqueryPublishSemanticHighlighting = "$cquery/publishSemanticHighlighting";
return "$/cancelRequest";
case IpcId::Initialized:
return "initialized";
case IpcId::Exit:
return "exit";
#define CASE(name, method) \
case IpcId::name: \
return method;
#include "methods.inc"
#undef CASE
case IpcId::Unknown:
return "$unknown";
}
CQUERY_UNREACHABLE("missing IpcId string name");
}
BaseIpcMessage::BaseIpcMessage(IpcId method_id) : method_id(method_id) {}
BaseIpcMessage::~BaseIpcMessage() = default; BaseIpcMessage::~BaseIpcMessage() = default;

40
src/ipc.h
View File

@ -7,48 +7,26 @@
using lsRequestId = std::variant<std::monostate, int64_t, std::string>; using lsRequestId = std::variant<std::monostate, int64_t, std::string>;
enum class IpcId : int { using MethodType = std::string;
// Language server specific requests.
CancelRequest = 0,
Initialized,
Exit,
#define CASE(x, _) x, extern const char* kMethodType_Unknown;
#include "methods.inc" extern const char* kMethodType_Exit;
#undef CASE extern const char* kMethodType_TextDocumentPublishDiagnostics;
extern const char* kMethodType_CqueryPublishInactiveRegions;
// Internal implementation detail. extern const char* kMethodType_CqueryPublishSemanticHighlighting;
Unknown,
};
MAKE_ENUM_HASHABLE(IpcId)
MAKE_REFLECT_TYPE_PROXY(IpcId)
const char* IpcIdToString(IpcId id);
struct BaseIpcMessage { struct BaseIpcMessage {
const IpcId method_id;
BaseIpcMessage(IpcId method_id);
virtual ~BaseIpcMessage(); virtual ~BaseIpcMessage();
virtual MethodType GetMethodType() const = 0;
virtual lsRequestId GetRequestId(); virtual lsRequestId GetRequestId();
template <typename T>
T* As() {
assert(method_id == T::kIpcId);
return static_cast<T*>(this);
}
}; };
template <typename T>
struct RequestMessage : public BaseIpcMessage { struct RequestMessage : public BaseIpcMessage {
// number | string, actually no null // number or string, actually no null
lsRequestId id; lsRequestId id;
RequestMessage() : BaseIpcMessage(T::kIpcId) {}
lsRequestId GetRequestId() override { return id; } lsRequestId GetRequestId() override { return id; }
}; };
// NotificationMessage does not have |id|. // NotificationMessage does not have |id|.
template <typename T> struct NotificationMessage : public BaseIpcMessage {};
struct NotificationMessage : public BaseIpcMessage {
NotificationMessage() : BaseIpcMessage(T::kIpcId) {}
};

11
src/lsp.h
View File

@ -24,7 +24,7 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#define REGISTER_IPC_MESSAGE(type) \ #define REGISTER_IN_MESSAGE(type) \
static MessageRegistryRegister<type> type##message_handler_instance_; static MessageRegistryRegister<type> type##message_handler_instance_;
struct MessageRegistry { struct MessageRegistry {
@ -44,7 +44,8 @@ struct MessageRegistry {
template <typename T> template <typename T>
struct MessageRegistryRegister { struct MessageRegistryRegister {
MessageRegistryRegister() { MessageRegistryRegister() {
std::string method_name = IpcIdToString(T::kIpcId); T dummy;
std::string method_name = dummy.GetMethodType();
MessageRegistry::instance()->allocators[method_name] = MessageRegistry::instance()->allocators[method_name] =
[](Reader& visitor, std::unique_ptr<BaseIpcMessage>* message) { [](Reader& visitor, std::unique_ptr<BaseIpcMessage>* message) {
*message = std::make_unique<T>(); *message = std::make_unique<T>();
@ -334,12 +335,6 @@ struct lsFormattingOptions {
}; };
MAKE_REFLECT_STRUCT(lsFormattingOptions, tabSize, insertSpaces); MAKE_REFLECT_STRUCT(lsFormattingOptions, tabSize, insertSpaces);
// Cancel an existing request.
struct Ipc_CancelRequest : public RequestMessage<Ipc_CancelRequest> {
static const IpcId kIpcId = IpcId::CancelRequest;
};
MAKE_REFLECT_STRUCT(Ipc_CancelRequest, id);
// MarkedString can be used to render human readable text. It is either a // MarkedString can be used to render human readable text. It is either a
// markdown string or a code-block that provides a language and a code snippet. // markdown string or a code-block that provides a language and a code snippet.
// The language identifier is sematically equal to the optional language // The language identifier is sematically equal to the optional language

2
src/match.cc
View File

@ -32,7 +32,7 @@ optional<Matcher> Matcher::Create(const std::string& search) {
out.params.type = lsMessageType::Error; out.params.type = lsMessageType::Error;
out.params.message = "cquery: Parsing EMCAScript regex \"" + search + out.params.message = "cquery: Parsing EMCAScript regex \"" + search +
"\" failed; " + e.what(); "\" failed; " + e.what();
QueueManager::WriteStdout(IpcId::Unknown, out); QueueManager::WriteStdout(kMethodType_Unknown, out);
return nullopt; return nullopt;
} }
} }

6
src/message_handler.cc
View File

@ -99,7 +99,7 @@ bool FindFileOrFail(QueryDatabase* db,
out.error.code = lsErrorCodes::InternalError; out.error.code = lsErrorCodes::InternalError;
out.error.message = "Unable to find file " + absolute_path; out.error.message = "Unable to find file " + absolute_path;
} }
QueueManager::WriteStdout(IpcId::Unknown, out); QueueManager::WriteStdout(kMethodType_Unknown, out);
} }
return false; return false;
@ -114,7 +114,7 @@ void EmitInactiveLines(WorkingFile* working_file,
if (ls_skipped) if (ls_skipped)
out.params.inactiveRegions.push_back(*ls_skipped); out.params.inactiveRegions.push_back(*ls_skipped);
} }
QueueManager::WriteStdout(IpcId::CqueryPublishInactiveRegions, out); QueueManager::WriteStdout(kMethodType_CqueryPublishInactiveRegions, out);
} }
void EmitSemanticHighlighting(QueryDatabase* db, void EmitSemanticHighlighting(QueryDatabase* db,
@ -277,7 +277,7 @@ void EmitSemanticHighlighting(QueryDatabase* db,
for (auto& entry : grouped_symbols) for (auto& entry : grouped_symbols)
if (entry.second.ranges.size()) if (entry.second.ranges.size())
out.params.symbols.push_back(entry.second); out.params.symbols.push_back(entry.second);
QueueManager::WriteStdout(IpcId::CqueryPublishSemanticHighlighting, out); QueueManager::WriteStdout(kMethodType_CqueryPublishSemanticHighlighting, out);
} }
bool ShouldIgnoreFileForIndexing(const std::string& path) { bool ShouldIgnoreFileForIndexing(const std::string& path) {

5
src/message_handler.h
View File

@ -86,7 +86,7 @@ struct MessageHandler {
CodeCompleteCache* non_global_code_complete_cache = nullptr; CodeCompleteCache* non_global_code_complete_cache = nullptr;
CodeCompleteCache* signature_cache = nullptr; CodeCompleteCache* signature_cache = nullptr;
virtual IpcId GetId() const = 0; virtual MethodType GetMethodType() const = 0;
virtual void Run(std::unique_ptr<BaseIpcMessage> message) = 0; virtual void Run(std::unique_ptr<BaseIpcMessage> message) = 0;
static std::vector<MessageHandler*>* message_handlers; static std::vector<MessageHandler*>* message_handlers;
@ -100,9 +100,8 @@ struct BaseMessageHandler : MessageHandler {
virtual void Run(TMessage* message) = 0; virtual void Run(TMessage* message) = 0;
// MessageHandler: // MessageHandler:
IpcId GetId() const override { return TMessage::kIpcId; }
void Run(std::unique_ptr<BaseIpcMessage> message) override { void Run(std::unique_ptr<BaseIpcMessage> message) override {
Run(message->As<TMessage>()); Run(static_cast<TMessage*>(message.get()));
} }
}; };

22
src/messages/cquery_base.cc
View File

@ -3,15 +3,21 @@
#include "queue_manager.h" #include "queue_manager.h"
namespace { namespace {
struct Ipc_CqueryBase : public RequestMessage<Ipc_CqueryBase> {
const static IpcId kIpcId = IpcId::CqueryBase; MethodType kMethodType = "$cquery/base";
struct In_CqueryBase : public RequestMessage {
MethodType GetMethodType() const override { return kMethodType; }
lsTextDocumentPositionParams params; lsTextDocumentPositionParams params;
}; };
MAKE_REFLECT_STRUCT(Ipc_CqueryBase, id, params); MAKE_REFLECT_STRUCT(In_CqueryBase, id, params);
REGISTER_IPC_MESSAGE(Ipc_CqueryBase); REGISTER_IN_MESSAGE(In_CqueryBase);
struct CqueryBaseHandler : BaseMessageHandler<Ipc_CqueryBase> { struct Handler_CqueryBase : BaseMessageHandler<In_CqueryBase> {
void Run(Ipc_CqueryBase* request) override { MethodType GetMethodType() const override { return kMethodType; }
void Run(In_CqueryBase* request) override {
QueryFile* file; QueryFile* file;
if (!FindFileOrFail(db, project, request->id, if (!FindFileOrFail(db, project, request->id,
request->params.textDocument.uri.GetPath(), &file)) { request->params.textDocument.uri.GetPath(), &file)) {
@ -39,8 +45,8 @@ struct CqueryBaseHandler : BaseMessageHandler<Ipc_CqueryBase> {
break; break;
} }
} }
QueueManager::WriteStdout(IpcId::CqueryBase, out); QueueManager::WriteStdout(kMethodType, out);
} }
}; };
REGISTER_MESSAGE_HANDLER(CqueryBaseHandler); REGISTER_MESSAGE_HANDLER(Handler_CqueryBase);
} // namespace } // namespace

28
src/messages/cquery_call_hierarchy.cc
View File

@ -5,6 +5,9 @@
#include <loguru.hpp> #include <loguru.hpp>
namespace { namespace {
MethodType kMethodType = "$cquery/callHierarchy";
enum class CallType : uint8_t { enum class CallType : uint8_t {
Direct = 0, Direct = 0,
Base = 1, Base = 1,
@ -17,9 +20,9 @@ bool operator&(CallType lhs, CallType rhs) {
return uint8_t(lhs) & uint8_t(rhs); return uint8_t(lhs) & uint8_t(rhs);
} }
struct Ipc_CqueryCallHierarchy struct In_CqueryCallHierarchy : public RequestMessage {
: public RequestMessage<Ipc_CqueryCallHierarchy> { MethodType GetMethodType() const override { return kMethodType; }
const static IpcId kIpcId = IpcId::CqueryCallHierarchy;
struct Params { struct Params {
// If id is specified, expand a node; otherwise textDocument+position should // If id is specified, expand a node; otherwise textDocument+position should
// be specified for building the root and |levels| of nodes below. // be specified for building the root and |levels| of nodes below.
@ -38,8 +41,9 @@ struct Ipc_CqueryCallHierarchy
int levels = 1; int levels = 1;
}; };
Params params; Params params;
}; };
MAKE_REFLECT_STRUCT(Ipc_CqueryCallHierarchy::Params, MAKE_REFLECT_STRUCT(In_CqueryCallHierarchy::Params,
textDocument, textDocument,
position, position,
id, id,
@ -47,8 +51,8 @@ MAKE_REFLECT_STRUCT(Ipc_CqueryCallHierarchy::Params,
callType, callType,
detailedName, detailedName,
levels); levels);
MAKE_REFLECT_STRUCT(Ipc_CqueryCallHierarchy, id, params); MAKE_REFLECT_STRUCT(In_CqueryCallHierarchy, id, params);
REGISTER_IPC_MESSAGE(Ipc_CqueryCallHierarchy); REGISTER_IN_MESSAGE(In_CqueryCallHierarchy);
struct Out_CqueryCallHierarchy : public lsOutMessage<Out_CqueryCallHierarchy> { struct Out_CqueryCallHierarchy : public lsOutMessage<Out_CqueryCallHierarchy> {
struct Entry { struct Entry {
@ -155,8 +159,10 @@ bool Expand(MessageHandler* m,
return true; return true;
} }
struct CqueryCallHierarchyHandler struct Handler_CqueryCallHierarchy
: BaseMessageHandler<Ipc_CqueryCallHierarchy> { : BaseMessageHandler<In_CqueryCallHierarchy> {
MethodType GetMethodType() const override { return kMethodType; }
optional<Out_CqueryCallHierarchy::Entry> BuildInitial(QueryFuncId root_id, optional<Out_CqueryCallHierarchy::Entry> BuildInitial(QueryFuncId root_id,
bool callee, bool callee,
CallType call_type, CallType call_type,
@ -178,7 +184,7 @@ struct CqueryCallHierarchyHandler
return entry; return entry;
} }
void Run(Ipc_CqueryCallHierarchy* request) override { void Run(In_CqueryCallHierarchy* request) override {
const auto& params = request->params; const auto& params = request->params;
Out_CqueryCallHierarchy out; Out_CqueryCallHierarchy out;
out.id = request->id; out.id = request->id;
@ -209,9 +215,9 @@ struct CqueryCallHierarchyHandler
} }
} }
QueueManager::WriteStdout(IpcId::CqueryCallHierarchy, out); QueueManager::WriteStdout(kMethodType, out);
} }
}; };
REGISTER_MESSAGE_HANDLER(CqueryCallHierarchyHandler); REGISTER_MESSAGE_HANDLER(Handler_CqueryCallHierarchy);
} // namespace } // namespace

19
src/messages/cquery_callers.cc
View File

@ -3,15 +3,18 @@
#include "queue_manager.h" #include "queue_manager.h"
namespace { namespace {
struct Ipc_CqueryCallers : public RequestMessage<Ipc_CqueryCallers> { MethodType kMethodType = "$cquery/callers";
const static IpcId kIpcId = IpcId::CqueryCallers;
struct In_CqueryCallers : public RequestMessage {
MethodType GetMethodType() const override { return kMethodType; }
lsTextDocumentPositionParams params; lsTextDocumentPositionParams params;
}; };
MAKE_REFLECT_STRUCT(Ipc_CqueryCallers, id, params); MAKE_REFLECT_STRUCT(In_CqueryCallers, id, params);
REGISTER_IPC_MESSAGE(Ipc_CqueryCallers); REGISTER_IN_MESSAGE(In_CqueryCallers);
struct CqueryCallersHandler : BaseMessageHandler<Ipc_CqueryCallers> { struct Handler_CqueryCallers : BaseMessageHandler<In_CqueryCallers> {
void Run(Ipc_CqueryCallers* request) override { MethodType GetMethodType() const override { return kMethodType; }
void Run(In_CqueryCallers* request) override {
QueryFile* file; QueryFile* file;
if (!FindFileOrFail(db, project, request->id, if (!FindFileOrFail(db, project, request->id,
request->params.textDocument.uri.GetPath(), &file)) { request->params.textDocument.uri.GetPath(), &file)) {
@ -38,8 +41,8 @@ struct CqueryCallersHandler : BaseMessageHandler<Ipc_CqueryCallers> {
break; break;
} }
} }
QueueManager::WriteStdout(IpcId::CqueryCallers, out); QueueManager::WriteStdout(kMethodType, out);
} }
}; };
REGISTER_MESSAGE_HANDLER(CqueryCallersHandler); REGISTER_MESSAGE_HANDLER(Handler_CqueryCallers);
} // namespace } // namespace

19
src/messages/cquery_derived.cc
View File

@ -3,15 +3,18 @@
#include "queue_manager.h" #include "queue_manager.h"
namespace { namespace {
struct Ipc_CqueryDerived : public RequestMessage<Ipc_CqueryDerived> { MethodType kMethodType = "$cquery/derived";
const static IpcId kIpcId = IpcId::CqueryDerived;
struct In_CqueryDerived : public RequestMessage {
MethodType GetMethodType() const override { return kMethodType; }
lsTextDocumentPositionParams params; lsTextDocumentPositionParams params;
}; };
MAKE_REFLECT_STRUCT(Ipc_CqueryDerived, id, params); MAKE_REFLECT_STRUCT(In_CqueryDerived, id, params);
REGISTER_IPC_MESSAGE(Ipc_CqueryDerived); REGISTER_IN_MESSAGE(In_CqueryDerived);
struct CqueryDerivedHandler : BaseMessageHandler<Ipc_CqueryDerived> { struct Handler_CqueryDerived : BaseMessageHandler<In_CqueryDerived> {
void Run(Ipc_CqueryDerived* request) override { MethodType GetMethodType() const override { return kMethodType; }
void Run(In_CqueryDerived* request) override {
QueryFile* file; QueryFile* file;
if (!FindFileOrFail(db, project, request->id, if (!FindFileOrFail(db, project, request->id,
request->params.textDocument.uri.GetPath(), &file)) { request->params.textDocument.uri.GetPath(), &file)) {
@ -39,8 +42,8 @@ struct CqueryDerivedHandler : BaseMessageHandler<Ipc_CqueryDerived> {
break; break;
} }
} }
QueueManager::WriteStdout(IpcId::CqueryDerived, out); QueueManager::WriteStdout(kMethodType, out);
} }
}; };
REGISTER_MESSAGE_HANDLER(CqueryDerivedHandler); REGISTER_MESSAGE_HANDLER(Handler_CqueryDerived);
} // namespace } // namespace

22
src/messages/cquery_did_view.cc
View File

@ -3,21 +3,23 @@
#include "working_files.h" #include "working_files.h"
namespace { namespace {
struct Ipc_CqueryTextDocumentDidView MethodType kMethodType = "$cquery/textDocumentDidView";
: public NotificationMessage<Ipc_CqueryTextDocumentDidView> {
const static IpcId kIpcId = IpcId::CqueryTextDocumentDidView; struct In_CqueryTextDocumentDidView : public NotificationMessage {
MethodType GetMethodType() const override { return kMethodType; }
struct Params { struct Params {
lsDocumentUri textDocumentUri; lsDocumentUri textDocumentUri;
}; };
Params params; Params params;
}; };
MAKE_REFLECT_STRUCT(Ipc_CqueryTextDocumentDidView::Params, textDocumentUri); MAKE_REFLECT_STRUCT(In_CqueryTextDocumentDidView::Params, textDocumentUri);
MAKE_REFLECT_STRUCT(Ipc_CqueryTextDocumentDidView, params); MAKE_REFLECT_STRUCT(In_CqueryTextDocumentDidView, params);
REGISTER_IPC_MESSAGE(Ipc_CqueryTextDocumentDidView); REGISTER_IN_MESSAGE(In_CqueryTextDocumentDidView);
struct CqueryDidViewHandler struct Handler_CqueryDidView
: BaseMessageHandler<Ipc_CqueryTextDocumentDidView> { : BaseMessageHandler<In_CqueryTextDocumentDidView> {
void Run(Ipc_CqueryTextDocumentDidView* request) override { MethodType GetMethodType() const override { return kMethodType; }
void Run(In_CqueryTextDocumentDidView* request) override {
std::string path = request->params.textDocumentUri.GetPath(); std::string path = request->params.textDocumentUri.GetPath();
WorkingFile* working_file = working_files->GetFileByFilename(path); WorkingFile* working_file = working_files->GetFileByFilename(path);
@ -34,5 +36,5 @@ struct CqueryDidViewHandler
} }
} }
}; };
REGISTER_MESSAGE_HANDLER(CqueryDidViewHandler); REGISTER_MESSAGE_HANDLER(Handler_CqueryDidView);
} // namespace } // namespace

19
src/messages/cquery_file_info.cc
View File

@ -3,17 +3,19 @@
#include "queue_manager.h" #include "queue_manager.h"
namespace { namespace {
MethodType kMethodType = "$cquery/fileInfo";
struct lsDocumentSymbolParams { struct lsDocumentSymbolParams {
lsTextDocumentIdentifier textDocument; lsTextDocumentIdentifier textDocument;
}; };
MAKE_REFLECT_STRUCT(lsDocumentSymbolParams, textDocument); MAKE_REFLECT_STRUCT(lsDocumentSymbolParams, textDocument);
struct Ipc_CqueryFileInfo : public RequestMessage<Ipc_CqueryFileInfo> { struct In_CqueryFileInfo : public RequestMessage {
const static IpcId kIpcId = IpcId::CqueryFileInfo; MethodType GetMethodType() const override { return kMethodType; }
lsDocumentSymbolParams params; lsDocumentSymbolParams params;
}; };
MAKE_REFLECT_STRUCT(Ipc_CqueryFileInfo, id, params); MAKE_REFLECT_STRUCT(In_CqueryFileInfo, id, params);
REGISTER_IPC_MESSAGE(Ipc_CqueryFileInfo); REGISTER_IN_MESSAGE(In_CqueryFileInfo);
struct Out_CqueryFileInfo : public lsOutMessage<Out_CqueryFileInfo> { struct Out_CqueryFileInfo : public lsOutMessage<Out_CqueryFileInfo> {
lsRequestId id; lsRequestId id;
@ -21,8 +23,9 @@ struct Out_CqueryFileInfo : public lsOutMessage<Out_CqueryFileInfo> {
}; };
MAKE_REFLECT_STRUCT(Out_CqueryFileInfo, jsonrpc, id, result); MAKE_REFLECT_STRUCT(Out_CqueryFileInfo, jsonrpc, id, result);
struct CqueryFileInfoHandler : BaseMessageHandler<Ipc_CqueryFileInfo> { struct Handler_CqueryFileInfo : BaseMessageHandler<In_CqueryFileInfo> {
void Run(Ipc_CqueryFileInfo* request) override { MethodType GetMethodType() const override { return kMethodType; }
void Run(In_CqueryFileInfo* request) override {
QueryFile* file; QueryFile* file;
if (!FindFileOrFail(db, project, request->id, if (!FindFileOrFail(db, project, request->id,
request->params.textDocument.uri.GetPath(), &file)) { request->params.textDocument.uri.GetPath(), &file)) {
@ -37,8 +40,8 @@ struct CqueryFileInfoHandler : BaseMessageHandler<Ipc_CqueryFileInfo> {
out.result.language = file->def->language; out.result.language = file->def->language;
out.result.includes = file->def->includes; out.result.includes = file->def->includes;
out.result.inactive_regions = file->def->inactive_regions; out.result.inactive_regions = file->def->inactive_regions;
QueueManager::WriteStdout(IpcId::CqueryFileInfo, out); QueueManager::WriteStdout(kMethodType, out);
} }
}; };
REGISTER_MESSAGE_HANDLER(CqueryFileInfoHandler); REGISTER_MESSAGE_HANDLER(Handler_CqueryFileInfo);
} // namespace } // namespace

20
src/messages/cquery_freshen_index.cc
View File

@ -13,9 +13,10 @@
#include <unordered_set> #include <unordered_set>
namespace { namespace {
struct Ipc_CqueryFreshenIndex MethodType kMethodType = "$cquery/freshenIndex";
: public NotificationMessage<Ipc_CqueryFreshenIndex> {
const static IpcId kIpcId = IpcId::CqueryFreshenIndex; struct In_CqueryFreshenIndex : public NotificationMessage {
MethodType GetMethodType() const override { return kMethodType; }
struct Params { struct Params {
bool dependencies = true; bool dependencies = true;
std::vector<std::string> whitelist; std::vector<std::string> whitelist;
@ -23,15 +24,16 @@ struct Ipc_CqueryFreshenIndex
}; };
Params params; Params params;
}; };
MAKE_REFLECT_STRUCT(Ipc_CqueryFreshenIndex::Params, MAKE_REFLECT_STRUCT(In_CqueryFreshenIndex::Params,
dependencies, dependencies,
whitelist, whitelist,
blacklist); blacklist);
MAKE_REFLECT_STRUCT(Ipc_CqueryFreshenIndex, params); MAKE_REFLECT_STRUCT(In_CqueryFreshenIndex, params);
REGISTER_IPC_MESSAGE(Ipc_CqueryFreshenIndex); REGISTER_IN_MESSAGE(In_CqueryFreshenIndex);
struct CqueryFreshenIndexHandler : BaseMessageHandler<Ipc_CqueryFreshenIndex> { struct Handler_CqueryFreshenIndex : BaseMessageHandler<In_CqueryFreshenIndex> {
void Run(Ipc_CqueryFreshenIndex* request) override { MethodType GetMethodType() const override { return kMethodType; }
void Run(In_CqueryFreshenIndex* request) override {
LOG_S(INFO) << "Freshening " << project->entries.size() << " files"; LOG_S(INFO) << "Freshening " << project->entries.size() << " files";
// TODO: think about this flow and test it more. // TODO: think about this flow and test it more.
@ -90,5 +92,5 @@ struct CqueryFreshenIndexHandler : BaseMessageHandler<Ipc_CqueryFreshenIndex> {
time.ResetAndPrint("[perf] Dispatched $cquery/freshenIndex index requests"); time.ResetAndPrint("[perf] Dispatched $cquery/freshenIndex index requests");
} }
}; };
REGISTER_MESSAGE_HANDLER(CqueryFreshenIndexHandler); REGISTER_MESSAGE_HANDLER(Handler_CqueryFreshenIndex);
} // namespace } // namespace

19
src/messages/cquery_index_file.cc
View File

@ -6,8 +6,10 @@
#include <loguru/loguru.hpp> #include <loguru/loguru.hpp>
namespace { namespace {
struct Ipc_CqueryIndexFile : public NotificationMessage<Ipc_CqueryIndexFile> { MethodType kMethodType = "$cquery/indexFile";
static constexpr IpcId kIpcId = IpcId::CqueryIndexFile;
struct In_CqueryIndexFile : public NotificationMessage {
MethodType GetMethodType() const override { return kMethodType; }
struct Params { struct Params {
std::string path; std::string path;
std::vector<std::string> args; std::vector<std::string> args;
@ -16,16 +18,17 @@ struct Ipc_CqueryIndexFile : public NotificationMessage<Ipc_CqueryIndexFile> {
}; };
Params params; Params params;
}; };
MAKE_REFLECT_STRUCT(Ipc_CqueryIndexFile::Params, MAKE_REFLECT_STRUCT(In_CqueryIndexFile::Params,
path, path,
args, args,
is_interactive, is_interactive,
contents); contents);
MAKE_REFLECT_STRUCT(Ipc_CqueryIndexFile, params); MAKE_REFLECT_STRUCT(In_CqueryIndexFile, params);
REGISTER_IPC_MESSAGE(Ipc_CqueryIndexFile); REGISTER_IN_MESSAGE(In_CqueryIndexFile);
struct CqueryIndexFileHandler : BaseMessageHandler<Ipc_CqueryIndexFile> { struct Handler_CqueryIndexFile : BaseMessageHandler<In_CqueryIndexFile> {
void Run(Ipc_CqueryIndexFile* request) override { MethodType GetMethodType() const override { return kMethodType; }
void Run(In_CqueryIndexFile* request) override {
LOG_S(INFO) << "Indexing file " << request->params.path; LOG_S(INFO) << "Indexing file " << request->params.path;
QueueManager::instance()->index_request.PushBack( QueueManager::instance()->index_request.PushBack(
Index_Request(NormalizePath(request->params.path), request->params.args, Index_Request(NormalizePath(request->params.path), request->params.args,
@ -33,5 +36,5 @@ struct CqueryIndexFileHandler : BaseMessageHandler<Ipc_CqueryIndexFile> {
ICacheManager::Make(config))); ICacheManager::Make(config)));
} }
}; };
REGISTER_MESSAGE_HANDLER(CqueryIndexFileHandler); REGISTER_MESSAGE_HANDLER(Handler_CqueryIndexFile);
} // namespace } // namespace

25
src/messages/cquery_inheritance_hierarchy.cc
View File

@ -3,9 +3,10 @@
#include "queue_manager.h" #include "queue_manager.h"
namespace { namespace {
struct Ipc_CqueryInheritanceHierarchy MethodType kMethodType = "$cquery/inheritanceHierarchy";
: public RequestMessage<Ipc_CqueryInheritanceHierarchy> {
const static IpcId kIpcId = IpcId::CqueryInheritanceHierarchy; struct In_CqueryInheritanceHierarchy : public RequestMessage {
MethodType GetMethodType() const override { return kMethodType; }
struct Params { struct Params {
// If id+kind are specified, expand a node; otherwise textDocument+position // If id+kind are specified, expand a node; otherwise textDocument+position
// should be specified for building the root and |levels| of nodes below. // should be specified for building the root and |levels| of nodes below.
@ -23,7 +24,7 @@ struct Ipc_CqueryInheritanceHierarchy
Params params; Params params;
}; };
MAKE_REFLECT_STRUCT(Ipc_CqueryInheritanceHierarchy::Params, MAKE_REFLECT_STRUCT(In_CqueryInheritanceHierarchy::Params,
textDocument, textDocument,
position, position,
id, id,
@ -31,8 +32,8 @@ MAKE_REFLECT_STRUCT(Ipc_CqueryInheritanceHierarchy::Params,
derived, derived,
detailedName, detailedName,
levels); levels);
MAKE_REFLECT_STRUCT(Ipc_CqueryInheritanceHierarchy, id, params); MAKE_REFLECT_STRUCT(In_CqueryInheritanceHierarchy, id, params);
REGISTER_IPC_MESSAGE(Ipc_CqueryInheritanceHierarchy); REGISTER_IN_MESSAGE(In_CqueryInheritanceHierarchy);
struct Out_CqueryInheritanceHierarchy struct Out_CqueryInheritanceHierarchy
: public lsOutMessage<Out_CqueryInheritanceHierarchy> { : public lsOutMessage<Out_CqueryInheritanceHierarchy> {
@ -127,8 +128,10 @@ bool Expand(MessageHandler* m,
m->db->types[entry->id.id]); m->db->types[entry->id.id]);
} }
struct CqueryInheritanceHierarchyHandler struct Handler_CqueryInheritanceHierarchy
: BaseMessageHandler<Ipc_CqueryInheritanceHierarchy> { : BaseMessageHandler<In_CqueryInheritanceHierarchy> {
MethodType GetMethodType() const override { return kMethodType; }
optional<Out_CqueryInheritanceHierarchy::Entry> optional<Out_CqueryInheritanceHierarchy::Entry>
BuildInitial(SymbolRef sym, bool derived, bool detailed_name, int levels) { BuildInitial(SymbolRef sym, bool derived, bool detailed_name, int levels) {
Out_CqueryInheritanceHierarchy::Entry entry; Out_CqueryInheritanceHierarchy::Entry entry;
@ -138,7 +141,7 @@ struct CqueryInheritanceHierarchyHandler
return entry; return entry;
} }
void Run(Ipc_CqueryInheritanceHierarchy* request) override { void Run(In_CqueryInheritanceHierarchy* request) override {
const auto& params = request->params; const auto& params = request->params;
Out_CqueryInheritanceHierarchy out; Out_CqueryInheritanceHierarchy out;
out.id = request->id; out.id = request->id;
@ -171,9 +174,9 @@ struct CqueryInheritanceHierarchyHandler
} }
} }
QueueManager::WriteStdout(IpcId::CqueryInheritanceHierarchy, out); QueueManager::WriteStdout(kMethodType, out);
} }
}; };
REGISTER_MESSAGE_HANDLER(CqueryInheritanceHierarchyHandler); REGISTER_MESSAGE_HANDLER(Handler_CqueryInheritanceHierarchy);
} // namespace } // namespace

26
src/messages/cquery_member_hierarchy.cc
View File

@ -3,9 +3,11 @@
#include "queue_manager.h" #include "queue_manager.h"
namespace { namespace {
struct Ipc_CqueryMemberHierarchy MethodType kMethodType = "$cquery/memberHierarchy";
: public RequestMessage<Ipc_CqueryMemberHierarchy> {
const static IpcId kIpcId = IpcId::CqueryMemberHierarchy; struct In_CqueryMemberHierarchy : public RequestMessage {
MethodType GetMethodType() const override { return kMethodType; }
struct Params { struct Params {
// If id is specified, expand a node; otherwise textDocument+position should // If id is specified, expand a node; otherwise textDocument+position should
// be specified for building the root and |levels| of nodes below. // be specified for building the root and |levels| of nodes below.
@ -20,14 +22,14 @@ struct Ipc_CqueryMemberHierarchy
Params params; Params params;
}; };
MAKE_REFLECT_STRUCT(Ipc_CqueryMemberHierarchy::Params, MAKE_REFLECT_STRUCT(In_CqueryMemberHierarchy::Params,
textDocument, textDocument,
position, position,
id, id,
detailedName, detailedName,
levels); levels);
MAKE_REFLECT_STRUCT(Ipc_CqueryMemberHierarchy, id, params); MAKE_REFLECT_STRUCT(In_CqueryMemberHierarchy, id, params);
REGISTER_IPC_MESSAGE(Ipc_CqueryMemberHierarchy); REGISTER_IN_MESSAGE(In_CqueryMemberHierarchy);
struct Out_CqueryMemberHierarchy struct Out_CqueryMemberHierarchy
: public lsOutMessage<Out_CqueryMemberHierarchy> { : public lsOutMessage<Out_CqueryMemberHierarchy> {
@ -158,8 +160,10 @@ bool Expand(MessageHandler* m,
return true; return true;
} }
struct CqueryMemberHierarchyHandler struct Handler_CqueryMemberHierarchy
: BaseMessageHandler<Ipc_CqueryMemberHierarchy> { : BaseMessageHandler<In_CqueryMemberHierarchy> {
MethodType GetMethodType() const override { return kMethodType; }
optional<Out_CqueryMemberHierarchy::Entry> BuildInitial(QueryFuncId root_id, optional<Out_CqueryMemberHierarchy::Entry> BuildInitial(QueryFuncId root_id,
bool detailed_name, bool detailed_name,
int levels) { int levels) {
@ -202,7 +206,7 @@ struct CqueryMemberHierarchyHandler
return entry; return entry;
} }
void Run(Ipc_CqueryMemberHierarchy* request) override { void Run(In_CqueryMemberHierarchy* request) override {
const auto& params = request->params; const auto& params = request->params;
Out_CqueryMemberHierarchy out; Out_CqueryMemberHierarchy out;
out.id = request->id; out.id = request->id;
@ -246,9 +250,9 @@ struct CqueryMemberHierarchyHandler
} }
} }
QueueManager::WriteStdout(IpcId::CqueryMemberHierarchy, out); QueueManager::WriteStdout(kMethodType, out);
} }
}; };
REGISTER_MESSAGE_HANDLER(CqueryMemberHierarchyHandler); REGISTER_MESSAGE_HANDLER(Handler_CqueryMemberHierarchy);
} // namespace } // namespace

20
src/messages/cquery_random.cc
View File

@ -7,11 +7,13 @@
#include <numeric> #include <numeric>
namespace { namespace {
struct Ipc_CqueryRandom : public RequestMessage<Ipc_CqueryRandom> { MethodType kMethodType = "$cquery/random";
const static IpcId kIpcId = IpcId::CqueryRandom;
struct In_CqueryRandom : public RequestMessage {
MethodType GetMethodType() const override { return kMethodType; }
}; };
MAKE_REFLECT_STRUCT(Ipc_CqueryRandom, id); MAKE_REFLECT_STRUCT(In_CqueryRandom, id);
REGISTER_IPC_MESSAGE(Ipc_CqueryRandom); REGISTER_IN_MESSAGE(In_CqueryRandom);
const double kDeclWeight = 3; const double kDeclWeight = 3;
const double kDamping = 0.1; const double kDamping = 0.1;
@ -44,8 +46,10 @@ void Add(const std::unordered_map<SymbolIdx, int>& sym2id,
} }
} }
struct CqueryRandomHandler : BaseMessageHandler<Ipc_CqueryRandom> { struct Handler_CqueryRandom : BaseMessageHandler<In_CqueryRandom> {
void Run(Ipc_CqueryRandom* request) override { MethodType GetMethodType() const override { return kMethodType; }
void Run(In_CqueryRandom* request) override {
std::unordered_map<SymbolIdx, int> sym2id; std::unordered_map<SymbolIdx, int> sym2id;
std::vector<SymbolIdx> syms; std::vector<SymbolIdx> syms;
int n = 0; int n = 0;
@ -137,8 +141,8 @@ struct CqueryRandomHandler : BaseMessageHandler<Ipc_CqueryRandom> {
break; break;
} }
} }
QueueManager::WriteStdout(IpcId::CqueryRandom, out); QueueManager::WriteStdout(kMethodType, out);
} }
}; };
REGISTER_MESSAGE_HANDLER(CqueryRandomHandler); REGISTER_MESSAGE_HANDLER(Handler_CqueryRandom);
} // namespace } // namespace

21
src/messages/cquery_vars.cc
View File

@ -3,15 +3,20 @@
#include "queue_manager.h" #include "queue_manager.h"
namespace { namespace {
struct Ipc_CqueryVars : public RequestMessage<Ipc_CqueryVars> { MethodType kMethodType = "$cquery/vars";
const static IpcId kIpcId = IpcId::CqueryVars;
struct In_CqueryVars : public RequestMessage {
MethodType GetMethodType() const override { return kMethodType; }
lsTextDocumentPositionParams params; lsTextDocumentPositionParams params;
}; };
MAKE_REFLECT_STRUCT(Ipc_CqueryVars, id, params); MAKE_REFLECT_STRUCT(In_CqueryVars, id, params);
REGISTER_IPC_MESSAGE(Ipc_CqueryVars); REGISTER_IN_MESSAGE(In_CqueryVars);
struct CqueryVarsHandler : BaseMessageHandler<Ipc_CqueryVars> { struct Handler_CqueryVars : BaseMessageHandler<In_CqueryVars> {
void Run(Ipc_CqueryVars* request) override { MethodType GetMethodType() const override { return kMethodType; }
void Run(In_CqueryVars* request) override {
QueryFile* file; QueryFile* file;
if (!FindFileOrFail(db, project, request->id, if (!FindFileOrFail(db, project, request->id,
request->params.textDocument.uri.GetPath(), &file)) { request->params.textDocument.uri.GetPath(), &file)) {
@ -45,8 +50,8 @@ struct CqueryVarsHandler : BaseMessageHandler<Ipc_CqueryVars> {
} }
} }
} }
QueueManager::WriteStdout(IpcId::CqueryVars, out); QueueManager::WriteStdout(kMethodType, out);
} }
}; };
REGISTER_MESSAGE_HANDLER(CqueryVarsHandler); REGISTER_MESSAGE_HANDLER(Handler_CqueryVars);
} // namespace } // namespace

19
src/messages/cquery_wait.cc
View File

@ -6,14 +6,17 @@
#include <loguru.hpp> #include <loguru.hpp>
namespace { namespace {
struct Ipc_CqueryWait : public NotificationMessage<Ipc_CqueryWait> { MethodType kMethodType = "$cquery/wait";
static constexpr IpcId kIpcId = IpcId::CqueryWait;
}; struct In_CqueryWait : public NotificationMessage {
MAKE_REFLECT_EMPTY_STRUCT(Ipc_CqueryWait); MethodType GetMethodType() const override { return kMethodType; }
REGISTER_IPC_MESSAGE(Ipc_CqueryWait); };
MAKE_REFLECT_EMPTY_STRUCT(In_CqueryWait);
REGISTER_IN_MESSAGE(In_CqueryWait);
struct Handler_CqueryWait : MessageHandler {
MethodType GetMethodType() const override { return kMethodType; }
struct CqueryWaitHandler : MessageHandler {
IpcId GetId() const override { return IpcId::CqueryWait; }
void Run(std::unique_ptr<BaseIpcMessage> request) override { void Run(std::unique_ptr<BaseIpcMessage> request) override {
// TODO: use status message system here, then run querydb as normal? Maybe // TODO: use status message system here, then run querydb as normal? Maybe
// this cannot be a normal message, ie, it needs to be re-entrant. // this cannot be a normal message, ie, it needs to be re-entrant.
@ -40,5 +43,5 @@ struct CqueryWaitHandler : MessageHandler {
LOG_S(INFO) << "Done waiting for idle"; LOG_S(INFO) << "Done waiting for idle";
} }
}; };
REGISTER_MESSAGE_HANDLER(CqueryWaitHandler); REGISTER_MESSAGE_HANDLER(Handler_CqueryWait);
} // namespace } // namespace

16
src/messages/exit.cc
View File

@ -3,19 +3,19 @@
#include <loguru.hpp> #include <loguru.hpp>
namespace { namespace {
struct Ipc_Exit : public NotificationMessage<Ipc_Exit> { struct In_Exit : public NotificationMessage {
static const IpcId kIpcId = IpcId::Exit; MethodType GetMethodType() const override { return kMethodType_Exit; }
}; };
MAKE_REFLECT_EMPTY_STRUCT(Ipc_Exit); MAKE_REFLECT_EMPTY_STRUCT(In_Exit);
REGISTER_IPC_MESSAGE(Ipc_Exit); REGISTER_IN_MESSAGE(In_Exit);
struct ExitHandler : MessageHandler { struct Handler_Exit : MessageHandler {
IpcId GetId() const override { return IpcId::Exit; } MethodType GetMethodType() const override { return kMethodType_Exit; }
void Run(std::unique_ptr<BaseIpcMessage> request) override { void Run(std::unique_ptr<BaseIpcMessage> request) override {
LOG_S(INFO) << "Exiting; got IpcId::Exit"; LOG_S(INFO) << "Exiting; got exit message";
exit(0); exit(0);
} }
}; };
REGISTER_MESSAGE_HANDLER(ExitHandler); REGISTER_MESSAGE_HANDLER(Handler_Exit);
} // namespace } // namespace

21
src/messages/initialize.cc
View File

@ -23,6 +23,8 @@ extern std::string g_init_options;
namespace { namespace {
MethodType kMethodType = "initialize";
// Code Lens options. // Code Lens options.
struct lsCodeLensOptions { struct lsCodeLensOptions {
// Code lens has a resolve provider as well. // Code lens has a resolve provider as well.
@ -460,12 +462,13 @@ struct lsInitializeError {
}; };
MAKE_REFLECT_STRUCT(lsInitializeError, retry); MAKE_REFLECT_STRUCT(lsInitializeError, retry);
struct Ipc_InitializeRequest : public RequestMessage<Ipc_InitializeRequest> { struct In_InitializeRequest : public RequestMessage {
const static IpcId kIpcId = IpcId::Initialize; MethodType GetMethodType() const override { return kMethodType; }
lsInitializeParams params; lsInitializeParams params;
}; };
MAKE_REFLECT_STRUCT(Ipc_InitializeRequest, id, params); MAKE_REFLECT_STRUCT(In_InitializeRequest, id, params);
REGISTER_IPC_MESSAGE(Ipc_InitializeRequest); REGISTER_IN_MESSAGE(In_InitializeRequest);
struct Out_InitializeResponse : public lsOutMessage<Out_InitializeResponse> { struct Out_InitializeResponse : public lsOutMessage<Out_InitializeResponse> {
struct InitializeResult { struct InitializeResult {
@ -477,8 +480,10 @@ struct Out_InitializeResponse : public lsOutMessage<Out_InitializeResponse> {
MAKE_REFLECT_STRUCT(Out_InitializeResponse::InitializeResult, capabilities); MAKE_REFLECT_STRUCT(Out_InitializeResponse::InitializeResult, capabilities);
MAKE_REFLECT_STRUCT(Out_InitializeResponse, jsonrpc, id, result); MAKE_REFLECT_STRUCT(Out_InitializeResponse, jsonrpc, id, result);
struct InitializeHandler : BaseMessageHandler<Ipc_InitializeRequest> { struct Handler_Initialize : BaseMessageHandler<In_InitializeRequest> {
void Run(Ipc_InitializeRequest* request) override { MethodType GetMethodType() const override { return kMethodType; }
void Run(In_InitializeRequest* request) override {
// Log initialization parameters. // Log initialization parameters.
rapidjson::StringBuffer output; rapidjson::StringBuffer output;
rapidjson::Writer<rapidjson::StringBuffer> writer(output); rapidjson::Writer<rapidjson::StringBuffer> writer(output);
@ -573,7 +578,7 @@ struct InitializeHandler : BaseMessageHandler<Ipc_InitializeRequest> {
out.result.capabilities.documentRangeFormattingProvider = true; out.result.capabilities.documentRangeFormattingProvider = true;
#endif #endif
QueueManager::WriteStdout(IpcId::Initialize, out); QueueManager::WriteStdout(kMethodType, out);
// Set project root. // Set project root.
EnsureEndsInSlash(project_path); EnsureEndsInSlash(project_path);
@ -627,5 +632,5 @@ struct InitializeHandler : BaseMessageHandler<Ipc_InitializeRequest> {
} }
} }
}; };
REGISTER_MESSAGE_HANDLER(InitializeHandler); REGISTER_MESSAGE_HANDLER(Handler_Initialize);
} // namespace } // namespace

19
src/messages/shutdown.cc
View File

@ -2,11 +2,13 @@
#include "queue_manager.h" #include "queue_manager.h"
namespace { namespace {
struct Ipc_Shutdown : public RequestMessage<Ipc_Shutdown> { MethodType kMethodType = "shutdown";
static const IpcId kIpcId = IpcId::Shutdown;
struct In_Shutdown : public RequestMessage {
MethodType GetMethodType() const override { return kMethodType; }
}; };
MAKE_REFLECT_STRUCT(Ipc_Shutdown, id); MAKE_REFLECT_STRUCT(In_Shutdown, id);
REGISTER_IPC_MESSAGE(Ipc_Shutdown); REGISTER_IN_MESSAGE(In_Shutdown);
struct Out_Shutdown : public lsOutMessage<Out_Shutdown> { struct Out_Shutdown : public lsOutMessage<Out_Shutdown> {
lsRequestId id; // defaults to std::monostate (null) lsRequestId id; // defaults to std::monostate (null)
@ -14,12 +16,13 @@ struct Out_Shutdown : public lsOutMessage<Out_Shutdown> {
}; };
MAKE_REFLECT_STRUCT(Out_Shutdown, jsonrpc, id, result); MAKE_REFLECT_STRUCT(Out_Shutdown, jsonrpc, id, result);
struct ShutdownHandler : BaseMessageHandler<Ipc_Shutdown> { struct Handler_Shutdown : BaseMessageHandler<In_Shutdown> {
void Run(Ipc_Shutdown* request) override { MethodType GetMethodType() const override { return kMethodType; }
void Run(In_Shutdown* request) override {
Out_Shutdown out; Out_Shutdown out;
out.id = request->id; out.id = request->id;
QueueManager::WriteStdout(IpcId::TextDocumentDefinition, out); QueueManager::WriteStdout(kMethodType, out);
} }
}; };
REGISTER_MESSAGE_HANDLER(ShutdownHandler); REGISTER_MESSAGE_HANDLER(Handler_Shutdown);
} // namespace } // namespace

27
src/messages/text_document_code_action.cc
View File

@ -11,6 +11,7 @@
#include <loguru.hpp> #include <loguru.hpp>
namespace { namespace {
MethodType kMethodType = "textDocument/codeAction";
optional<int> FindIncludeLine(const std::vector<std::string>& lines, optional<int> FindIncludeLine(const std::vector<std::string>& lines,
const std::string& full_include_line) { const std::string& full_include_line) {
@ -256,9 +257,9 @@ optional<lsTextEdit> BuildAutoImplementForFunction(QueryDatabase* db,
return nullopt; return nullopt;
} }
struct Ipc_TextDocumentCodeAction struct In_TextDocumentCodeAction : public RequestMessage {
: public RequestMessage<Ipc_TextDocumentCodeAction> { MethodType GetMethodType() const override { return kMethodType; }
const static IpcId kIpcId = IpcId::TextDocumentCodeAction;
// Contains additional diagnostic information about the context in which // Contains additional diagnostic information about the context in which
// a code action is run. // a code action is run.
struct lsCodeActionContext { struct lsCodeActionContext {
@ -276,14 +277,14 @@ struct Ipc_TextDocumentCodeAction
}; };
lsCodeActionParams params; lsCodeActionParams params;
}; };
MAKE_REFLECT_STRUCT(Ipc_TextDocumentCodeAction::lsCodeActionContext, MAKE_REFLECT_STRUCT(In_TextDocumentCodeAction::lsCodeActionContext,
diagnostics); diagnostics);
MAKE_REFLECT_STRUCT(Ipc_TextDocumentCodeAction::lsCodeActionParams, MAKE_REFLECT_STRUCT(In_TextDocumentCodeAction::lsCodeActionParams,
textDocument, textDocument,
range, range,
context); context);
MAKE_REFLECT_STRUCT(Ipc_TextDocumentCodeAction, id, params); MAKE_REFLECT_STRUCT(In_TextDocumentCodeAction, id, params);
REGISTER_IPC_MESSAGE(Ipc_TextDocumentCodeAction); REGISTER_IN_MESSAGE(In_TextDocumentCodeAction);
struct Out_TextDocumentCodeAction struct Out_TextDocumentCodeAction
: public lsOutMessage<Out_TextDocumentCodeAction> { : public lsOutMessage<Out_TextDocumentCodeAction> {
@ -294,9 +295,11 @@ struct Out_TextDocumentCodeAction
}; };
MAKE_REFLECT_STRUCT(Out_TextDocumentCodeAction, jsonrpc, id, result); MAKE_REFLECT_STRUCT(Out_TextDocumentCodeAction, jsonrpc, id, result);
struct TextDocumentCodeActionHandler struct Handler_TextDocumentCodeAction
: BaseMessageHandler<Ipc_TextDocumentCodeAction> { : BaseMessageHandler<In_TextDocumentCodeAction> {
void Run(Ipc_TextDocumentCodeAction* request) override { MethodType GetMethodType() const override { return kMethodType; }
void Run(In_TextDocumentCodeAction* request) override {
// NOTE: This code snippet will generate some FixIts for testing: // NOTE: This code snippet will generate some FixIts for testing:
// //
// struct origin { int x, int y }; // struct origin { int x, int y };
@ -534,10 +537,10 @@ struct TextDocumentCodeActionHandler
} }
} }
QueueManager::WriteStdout(IpcId::TextDocumentCodeAction, out); QueueManager::WriteStdout(kMethodType, out);
} }
}; };
REGISTER_MESSAGE_HANDLER(TextDocumentCodeActionHandler); REGISTER_MESSAGE_HANDLER(Handler_TextDocumentCodeAction);
TEST_SUITE("FindIncludeLine") { TEST_SUITE("FindIncludeLine") {
TEST_CASE("in document") { TEST_CASE("in document") {

22
src/messages/text_document_code_lens.cc
View File

@ -5,19 +5,20 @@
#include "queue_manager.h" #include "queue_manager.h"
namespace { namespace {
MethodType kMethodType = "textDocument/codeLens";
struct lsDocumentCodeLensParams { struct lsDocumentCodeLensParams {
lsTextDocumentIdentifier textDocument; lsTextDocumentIdentifier textDocument;
}; };
MAKE_REFLECT_STRUCT(lsDocumentCodeLensParams, textDocument); MAKE_REFLECT_STRUCT(lsDocumentCodeLensParams, textDocument);
using TCodeLens = lsCodeLens<lsCodeLensUserData, lsCodeLensCommandArguments>; using TCodeLens = lsCodeLens<lsCodeLensUserData, lsCodeLensCommandArguments>;
struct Ipc_TextDocumentCodeLens struct In_TextDocumentCodeLens : public RequestMessage {
: public RequestMessage<Ipc_TextDocumentCodeLens> { MethodType GetMethodType() const override { return kMethodType; }
const static IpcId kIpcId = IpcId::TextDocumentCodeLens;
lsDocumentCodeLensParams params; lsDocumentCodeLensParams params;
}; };
MAKE_REFLECT_STRUCT(Ipc_TextDocumentCodeLens, id, params); MAKE_REFLECT_STRUCT(In_TextDocumentCodeLens, id, params);
REGISTER_IPC_MESSAGE(Ipc_TextDocumentCodeLens); REGISTER_IN_MESSAGE(In_TextDocumentCodeLens);
struct Out_TextDocumentCodeLens struct Out_TextDocumentCodeLens
: public lsOutMessage<Out_TextDocumentCodeLens> { : public lsOutMessage<Out_TextDocumentCodeLens> {
@ -81,9 +82,10 @@ void AddCodeLens(const char* singular,
common->result->push_back(code_lens); common->result->push_back(code_lens);
} }
struct TextDocumentCodeLensHandler struct Handler_TextDocumentCodeLens
: BaseMessageHandler<Ipc_TextDocumentCodeLens> { : BaseMessageHandler<In_TextDocumentCodeLens> {
void Run(Ipc_TextDocumentCodeLens* request) override { MethodType GetMethodType() const override { return kMethodType; }
void Run(In_TextDocumentCodeLens* request) override {
Out_TextDocumentCodeLens out; Out_TextDocumentCodeLens out;
out.id = request->id; out.id = request->id;
@ -225,8 +227,8 @@ struct TextDocumentCodeLensHandler
}; };
} }
QueueManager::WriteStdout(IpcId::TextDocumentCodeLens, out); QueueManager::WriteStdout(kMethodType, out);
} }
}; };
REGISTER_MESSAGE_HANDLER(TextDocumentCodeLensHandler); REGISTER_MESSAGE_HANDLER(Handler_TextDocumentCodeLens);
} // namespace } // namespace

26
src/messages/text_document_completion.cc
View File

@ -14,6 +14,7 @@
#include <regex> #include <regex>
namespace { namespace {
MethodType kMethodType = "textDocument/completion";
// How a completion was triggered // How a completion was triggered
enum class lsCompletionTriggerKind { enum class lsCompletionTriggerKind {
@ -47,13 +48,12 @@ struct lsCompletionParams : lsTextDocumentPositionParams {
}; };
MAKE_REFLECT_STRUCT(lsCompletionParams, textDocument, position, context); MAKE_REFLECT_STRUCT(lsCompletionParams, textDocument, position, context);
struct Ipc_TextDocumentComplete struct In_TextDocumentComplete : public RequestMessage {
: public RequestMessage<Ipc_TextDocumentComplete> { MethodType GetMethodType() const override { return kMethodType; }
const static IpcId kIpcId = IpcId::TextDocumentCompletion;
lsCompletionParams params; lsCompletionParams params;
}; };
MAKE_REFLECT_STRUCT(Ipc_TextDocumentComplete, id, params); MAKE_REFLECT_STRUCT(In_TextDocumentComplete, id, params);
REGISTER_IPC_MESSAGE(Ipc_TextDocumentComplete); REGISTER_IN_MESSAGE(In_TextDocumentComplete);
struct lsTextDocumentCompleteResult { struct lsTextDocumentCompleteResult {
// This list it not complete. Further typing should result in recomputing // This list it not complete. Further typing should result in recomputing
@ -216,17 +216,17 @@ void FilterAndSortCompletionResponse(
finalize(); finalize();
} }
struct TextDocumentCompletionHandler : MessageHandler { struct Handler_TextDocumentCompletion : MessageHandler {
IpcId GetId() const override { return IpcId::TextDocumentCompletion; } MethodType GetMethodType() const override { return kMethodType; }
void Run(std::unique_ptr<BaseIpcMessage> message) override { void Run(std::unique_ptr<BaseIpcMessage> message) override {
auto request = std::shared_ptr<Ipc_TextDocumentComplete>( auto request = std::shared_ptr<In_TextDocumentComplete>(
static_cast<Ipc_TextDocumentComplete*>(message.release())); static_cast<In_TextDocumentComplete*>(message.release()));
auto write_empty_result = [request]() { auto write_empty_result = [request]() {
Out_TextDocumentComplete out; Out_TextDocumentComplete out;
out.id = request->id; out.id = request->id;
QueueManager::WriteStdout(IpcId::TextDocumentCompletion, out); QueueManager::WriteStdout(kMethodType, out);
}; };
std::string path = request->params.textDocument.uri.GetPath(); std::string path = request->params.textDocument.uri.GetPath();
@ -324,7 +324,7 @@ struct TextDocumentCompletionHandler : MessageHandler {
item.textEdit->range.end.character = (int)buffer_line.size(); item.textEdit->range.end.character = (int)buffer_line.size();
} }
QueueManager::WriteStdout(IpcId::TextDocumentCompletion, out); QueueManager::WriteStdout(kMethodType, out);
} else { } else {
ClangCompleteManager::OnComplete callback = std::bind( ClangCompleteManager::OnComplete callback = std::bind(
[this, is_global_completion, existing_completion, request]( [this, is_global_completion, existing_completion, request](
@ -337,7 +337,7 @@ struct TextDocumentCompletionHandler : MessageHandler {
// Emit completion results. // Emit completion results.
FilterAndSortCompletionResponse(&out, existing_completion, FilterAndSortCompletionResponse(&out, existing_completion,
config->completion.filterAndSort); config->completion.filterAndSort);
QueueManager::WriteStdout(IpcId::TextDocumentCompletion, out); QueueManager::WriteStdout(kMethodType, out);
// Cache completion results. // Cache completion results.
if (!is_cached_result) { if (!is_cached_result) {
@ -395,6 +395,6 @@ struct TextDocumentCompletionHandler : MessageHandler {
} }
} }
}; };
REGISTER_MESSAGE_HANDLER(TextDocumentCompletionHandler); REGISTER_MESSAGE_HANDLER(Handler_TextDocumentCompletion);
} // namespace } // namespace

21
src/messages/text_document_definition.cc
View File

@ -8,14 +8,14 @@
#include <cstdlib> #include <cstdlib>
namespace { namespace {
MethodType kMethodType = "textDocument/definition";
struct Ipc_TextDocumentDefinition struct In_TextDocumentDefinition : public RequestMessage {
: public RequestMessage<Ipc_TextDocumentDefinition> { MethodType GetMethodType() const override { return kMethodType; }
const static IpcId kIpcId = IpcId::TextDocumentDefinition;
lsTextDocumentPositionParams params; lsTextDocumentPositionParams params;
}; };
MAKE_REFLECT_STRUCT(Ipc_TextDocumentDefinition, id, params); MAKE_REFLECT_STRUCT(In_TextDocumentDefinition, id, params);
REGISTER_IPC_MESSAGE(Ipc_TextDocumentDefinition); REGISTER_IN_MESSAGE(In_TextDocumentDefinition);
struct Out_TextDocumentDefinition struct Out_TextDocumentDefinition
: public lsOutMessage<Out_TextDocumentDefinition> { : public lsOutMessage<Out_TextDocumentDefinition> {
@ -46,9 +46,10 @@ std::vector<Use> GetNonDefDeclarationTargets(QueryDatabase* db, SymbolRef sym) {
} }
} }
struct TextDocumentDefinitionHandler struct Handler_TextDocumentDefinition
: BaseMessageHandler<Ipc_TextDocumentDefinition> { : BaseMessageHandler<In_TextDocumentDefinition> {
void Run(Ipc_TextDocumentDefinition* request) override { MethodType GetMethodType() const override { return kMethodType; }
void Run(In_TextDocumentDefinition* request) override {
QueryFileId file_id; QueryFileId file_id;
QueryFile* file; QueryFile* file;
if (!FindFileOrFail(db, project, request->id, if (!FindFileOrFail(db, project, request->id,
@ -165,8 +166,8 @@ struct TextDocumentDefinitionHandler
} }
} }
QueueManager::WriteStdout(IpcId::TextDocumentDefinition, out); QueueManager::WriteStdout(kMethodType, out);
} }
}; };
REGISTER_MESSAGE_HANDLER(TextDocumentDefinitionHandler); REGISTER_MESSAGE_HANDLER(Handler_TextDocumentDefinition);
} // namespace } // namespace

21
src/messages/text_document_did_change.cc
View File

@ -8,18 +8,21 @@
#include <loguru/loguru.hpp> #include <loguru/loguru.hpp>
namespace { namespace {
struct Ipc_TextDocumentDidChange MethodType kMethodType = "textDocument/didChange";
: public NotificationMessage<Ipc_TextDocumentDidChange> {
const static IpcId kIpcId = IpcId::TextDocumentDidChange; struct In_TextDocumentDidChange : public NotificationMessage {
MethodType GetMethodType() const override { return kMethodType; }
lsTextDocumentDidChangeParams params; lsTextDocumentDidChangeParams params;
}; };
MAKE_REFLECT_STRUCT(Ipc_TextDocumentDidChange, params); MAKE_REFLECT_STRUCT(In_TextDocumentDidChange, params);
REGISTER_IPC_MESSAGE(Ipc_TextDocumentDidChange); REGISTER_IN_MESSAGE(In_TextDocumentDidChange);
struct TextDocumentDidChangeHandler struct Handler_TextDocumentDidChange
: BaseMessageHandler<Ipc_TextDocumentDidChange> { : BaseMessageHandler<In_TextDocumentDidChange> {
void Run(Ipc_TextDocumentDidChange* request) override { MethodType GetMethodType() const override { return kMethodType; }
void Run(In_TextDocumentDidChange* request) override {
std::string path = request->params.textDocument.uri.GetPath(); std::string path = request->params.textDocument.uri.GetPath();
working_files->OnChange(request->params); working_files->OnChange(request->params);
if (config->enableIndexOnDidChange) { if (config->enableIndexOnDidChange) {
@ -40,5 +43,5 @@ struct TextDocumentDidChangeHandler
request->params.textDocument.AsTextDocumentIdentifier()); request->params.textDocument.AsTextDocumentIdentifier());
} }
}; };
REGISTER_MESSAGE_HANDLER(TextDocumentDidChangeHandler); REGISTER_MESSAGE_HANDLER(Handler_TextDocumentDidChange);
} // namespace } // namespace

25
src/messages/text_document_did_close.cc
View File

@ -4,32 +4,35 @@
#include "working_files.h" #include "working_files.h"
namespace { namespace {
struct Ipc_TextDocumentDidClose MethodType kMethodType = "textDocument/didClose";
: public NotificationMessage<Ipc_TextDocumentDidClose> {
const static IpcId kIpcId = IpcId::TextDocumentDidClose; struct In_TextDocumentDidClose : public NotificationMessage {
MethodType GetMethodType() const override { return kMethodType; }
struct Params { struct Params {
lsTextDocumentIdentifier textDocument; lsTextDocumentIdentifier textDocument;
}; };
Params params; Params params;
}; };
MAKE_REFLECT_STRUCT(Ipc_TextDocumentDidClose::Params, textDocument); MAKE_REFLECT_STRUCT(In_TextDocumentDidClose::Params, textDocument);
MAKE_REFLECT_STRUCT(Ipc_TextDocumentDidClose, params); MAKE_REFLECT_STRUCT(In_TextDocumentDidClose, params);
REGISTER_IPC_MESSAGE(Ipc_TextDocumentDidClose); REGISTER_IN_MESSAGE(In_TextDocumentDidClose);
struct TextDocumentDidCloseHandler struct Handler_TextDocumentDidClose
: BaseMessageHandler<Ipc_TextDocumentDidClose> { : BaseMessageHandler<In_TextDocumentDidClose> {
void Run(Ipc_TextDocumentDidClose* request) override { MethodType GetMethodType() const override { return kMethodType; }
void Run(In_TextDocumentDidClose* request) override {
std::string path = request->params.textDocument.uri.GetPath(); std::string path = request->params.textDocument.uri.GetPath();
// Clear any diagnostics for the file. // Clear any diagnostics for the file.
Out_TextDocumentPublishDiagnostics out; Out_TextDocumentPublishDiagnostics out;
out.params.uri = request->params.textDocument.uri; out.params.uri = request->params.textDocument.uri;
QueueManager::WriteStdout(IpcId::TextDocumentPublishDiagnostics, out); QueueManager::WriteStdout(kMethodType, out);
// Remove internal state. // Remove internal state.
working_files->OnClose(request->params.textDocument); working_files->OnClose(request->params.textDocument);
clang_complete->NotifyClose(path); clang_complete->NotifyClose(path);
} }
}; };
REGISTER_MESSAGE_HANDLER(TextDocumentDidCloseHandler); REGISTER_MESSAGE_HANDLER(Handler_TextDocumentDidClose);
} // namespace } // namespace

24
src/messages/text_document_did_open.cc
View File

@ -10,10 +10,12 @@
#include <loguru.hpp> #include <loguru.hpp>
namespace { namespace {
MethodType kMethodType = "textDocument/didOpen";
// Open, view, change, close file // Open, view, change, close file
struct Ipc_TextDocumentDidOpen struct In_TextDocumentDidOpen : public NotificationMessage {
: public NotificationMessage<Ipc_TextDocumentDidOpen> { MethodType GetMethodType() const override { return kMethodType; }
const static IpcId kIpcId = IpcId::TextDocumentDidOpen;
struct Params { struct Params {
lsTextDocumentItem textDocument; lsTextDocumentItem textDocument;
@ -24,13 +26,15 @@ struct Ipc_TextDocumentDidOpen
}; };
Params params; Params params;
}; };
MAKE_REFLECT_STRUCT(Ipc_TextDocumentDidOpen::Params, textDocument, args); MAKE_REFLECT_STRUCT(In_TextDocumentDidOpen::Params, textDocument, args);
MAKE_REFLECT_STRUCT(Ipc_TextDocumentDidOpen, params); MAKE_REFLECT_STRUCT(In_TextDocumentDidOpen, params);
REGISTER_IPC_MESSAGE(Ipc_TextDocumentDidOpen); REGISTER_IN_MESSAGE(In_TextDocumentDidOpen);
struct TextDocumentDidOpenHandler struct Handler_TextDocumentDidOpen
: BaseMessageHandler<Ipc_TextDocumentDidOpen> { : BaseMessageHandler<In_TextDocumentDidOpen> {
void Run(Ipc_TextDocumentDidOpen* request) override { MethodType GetMethodType() const override { return kMethodType; }
void Run(In_TextDocumentDidOpen* request) override {
// NOTE: This function blocks code lens. If it starts taking a long time // NOTE: This function blocks code lens. If it starts taking a long time
// we will need to find a way to unblock the code lens request. // we will need to find a way to unblock the code lens request.
const auto& params = request->params; const auto& params = request->params;
@ -75,5 +79,5 @@ struct TextDocumentDidOpenHandler
} }
} }
}; };
REGISTER_MESSAGE_HANDLER(TextDocumentDidOpenHandler); REGISTER_MESSAGE_HANDLER(Handler_TextDocumentDidOpen);
} // namespace } // namespace

24
src/messages/text_document_did_save.cc
View File

@ -7,9 +7,11 @@
#include <loguru/loguru.hpp> #include <loguru/loguru.hpp>
namespace { namespace {
struct Ipc_TextDocumentDidSave MethodType kMethodType = "textDocument/didSave";
: public NotificationMessage<Ipc_TextDocumentDidSave> {
const static IpcId kIpcId = IpcId::TextDocumentDidSave; struct In_TextDocumentDidSave : public NotificationMessage {
MethodType GetMethodType() const override { return kMethodType; }
struct Params { struct Params {
// The document that was saved. // The document that was saved.
lsTextDocumentIdentifier textDocument; lsTextDocumentIdentifier textDocument;
@ -20,13 +22,15 @@ struct Ipc_TextDocumentDidSave
}; };
Params params; Params params;
}; };
MAKE_REFLECT_STRUCT(Ipc_TextDocumentDidSave::Params, textDocument); MAKE_REFLECT_STRUCT(In_TextDocumentDidSave::Params, textDocument);
MAKE_REFLECT_STRUCT(Ipc_TextDocumentDidSave, params); MAKE_REFLECT_STRUCT(In_TextDocumentDidSave, params);
REGISTER_IPC_MESSAGE(Ipc_TextDocumentDidSave); REGISTER_IN_MESSAGE(In_TextDocumentDidSave);
struct TextDocumentDidSaveHandler struct Handler_TextDocumentDidSave
: BaseMessageHandler<Ipc_TextDocumentDidSave> { : BaseMessageHandler<In_TextDocumentDidSave> {
void Run(Ipc_TextDocumentDidSave* request) override { MethodType GetMethodType() const override { return kMethodType; }
void Run(In_TextDocumentDidSave* request) override {
std::string path = request->params.textDocument.uri.GetPath(); std::string path = request->params.textDocument.uri.GetPath();
if (ShouldIgnoreFileForIndexing(path)) if (ShouldIgnoreFileForIndexing(path))
return; return;
@ -61,5 +65,5 @@ struct TextDocumentDidSaveHandler
clang_complete->NotifySave(path); clang_complete->NotifySave(path);
} }
}; };
REGISTER_MESSAGE_HANDLER(TextDocumentDidSaveHandler); REGISTER_MESSAGE_HANDLER(Handler_TextDocumentDidSave);
} // namespace } // namespace

22
src/messages/text_document_document_highlight.cc
View File

@ -4,13 +4,14 @@
#include "symbol.h" #include "symbol.h"
namespace { namespace {
struct Ipc_TextDocumentDocumentHighlight MethodType kMethodType = "textDocument/documentHighlight";
: public RequestMessage<Ipc_TextDocumentDocumentHighlight> {
const static IpcId kIpcId = IpcId::TextDocumentDocumentHighlight; struct In_TextDocumentDocumentHighlight : public RequestMessage {
MethodType GetMethodType() const override { return kMethodType; }
lsTextDocumentPositionParams params; lsTextDocumentPositionParams params;
}; };
MAKE_REFLECT_STRUCT(Ipc_TextDocumentDocumentHighlight, id, params); MAKE_REFLECT_STRUCT(In_TextDocumentDocumentHighlight, id, params);
REGISTER_IPC_MESSAGE(Ipc_TextDocumentDocumentHighlight); REGISTER_IN_MESSAGE(In_TextDocumentDocumentHighlight);
struct Out_TextDocumentDocumentHighlight struct Out_TextDocumentDocumentHighlight
: public lsOutMessage<Out_TextDocumentDocumentHighlight> { : public lsOutMessage<Out_TextDocumentDocumentHighlight> {
@ -19,9 +20,10 @@ struct Out_TextDocumentDocumentHighlight
}; };
MAKE_REFLECT_STRUCT(Out_TextDocumentDocumentHighlight, jsonrpc, id, result); MAKE_REFLECT_STRUCT(Out_TextDocumentDocumentHighlight, jsonrpc, id, result);
struct TextDocumentDocumentHighlightHandler struct Handler_TextDocumentDocumentHighlight
: BaseMessageHandler<Ipc_TextDocumentDocumentHighlight> { : BaseMessageHandler<In_TextDocumentDocumentHighlight> {
void Run(Ipc_TextDocumentDocumentHighlight* request) override { MethodType GetMethodType() const override { return kMethodType; }
void Run(In_TextDocumentDocumentHighlight* request) override {
QueryFileId file_id; QueryFileId file_id;
QueryFile* file; QueryFile* file;
if (!FindFileOrFail(db, project, request->id, if (!FindFileOrFail(db, project, request->id,
@ -59,8 +61,8 @@ struct TextDocumentDocumentHighlightHandler
break; break;
} }
QueueManager::WriteStdout(IpcId::TextDocumentDocumentHighlight, out); QueueManager::WriteStdout(kMethodType, out);
} }
}; };
REGISTER_MESSAGE_HANDLER(TextDocumentDocumentHighlightHandler); REGISTER_MESSAGE_HANDLER(Handler_TextDocumentDocumentHighlight);
} // namespace } // namespace

24
src/messages/text_document_document_link.cc
View File

@ -6,18 +6,19 @@
#include <loguru.hpp> #include <loguru.hpp>
namespace { namespace {
struct Ipc_TextDocumentDocumentLink MethodType kMethodType = "textDocument/documentLink";
: public RequestMessage<Ipc_TextDocumentDocumentLink> {
const static IpcId kIpcId = IpcId::TextDocumentDocumentLink; struct In_TextDocumentDocumentLink : public RequestMessage {
MethodType GetMethodType() const override { return kMethodType; }
struct Params { struct Params {
// The document to provide document links for. // The document to provide document links for.
lsTextDocumentIdentifier textDocument; lsTextDocumentIdentifier textDocument;
}; };
Params params; Params params;
}; };
MAKE_REFLECT_STRUCT(Ipc_TextDocumentDocumentLink::Params, textDocument); MAKE_REFLECT_STRUCT(In_TextDocumentDocumentLink::Params, textDocument);
MAKE_REFLECT_STRUCT(Ipc_TextDocumentDocumentLink, id, params); MAKE_REFLECT_STRUCT(In_TextDocumentDocumentLink, id, params);
REGISTER_IPC_MESSAGE(Ipc_TextDocumentDocumentLink); REGISTER_IN_MESSAGE(In_TextDocumentDocumentLink);
// A document link is a range in a text document that links to an internal or // A document link is a range in a text document that links to an internal or
// external resource, like another text document or a web site. // external resource, like another text document or a web site.
@ -36,9 +37,10 @@ struct Out_TextDocumentDocumentLink
}; };
MAKE_REFLECT_STRUCT(Out_TextDocumentDocumentLink, jsonrpc, id, result); MAKE_REFLECT_STRUCT(Out_TextDocumentDocumentLink, jsonrpc, id, result);
struct TextDocumentDocumentLinkHandler struct Handler_TextDocumentDocumentLink
: BaseMessageHandler<Ipc_TextDocumentDocumentLink> { : BaseMessageHandler<In_TextDocumentDocumentLink> {
void Run(Ipc_TextDocumentDocumentLink* request) override { MethodType GetMethodType() const override { return kMethodType; }
void Run(In_TextDocumentDocumentLink* request) override {
Out_TextDocumentDocumentLink out; Out_TextDocumentDocumentLink out;
out.id = request->id; out.id = request->id;
@ -76,8 +78,8 @@ struct TextDocumentDocumentLinkHandler
} }
} }
QueueManager::WriteStdout(IpcId::TextDocumentDocumentLink, out); QueueManager::WriteStdout(kMethodType, out);
} }
}; };
REGISTER_MESSAGE_HANDLER(TextDocumentDocumentLinkHandler); REGISTER_MESSAGE_HANDLER(Handler_TextDocumentDocumentLink);
} // namespace } // namespace

22
src/messages/text_document_document_symbol.cc
View File

@ -3,18 +3,19 @@
#include "queue_manager.h" #include "queue_manager.h"
namespace { namespace {
MethodType kMethodType = "textDocument/documentSymbol";
struct lsDocumentSymbolParams { struct lsDocumentSymbolParams {
lsTextDocumentIdentifier textDocument; lsTextDocumentIdentifier textDocument;
}; };
MAKE_REFLECT_STRUCT(lsDocumentSymbolParams, textDocument); MAKE_REFLECT_STRUCT(lsDocumentSymbolParams, textDocument);
struct Ipc_TextDocumentDocumentSymbol struct In_TextDocumentDocumentSymbol : public RequestMessage {
: public RequestMessage<Ipc_TextDocumentDocumentSymbol> { MethodType GetMethodType() const override { return kMethodType; }
const static IpcId kIpcId = IpcId::TextDocumentDocumentSymbol;
lsDocumentSymbolParams params; lsDocumentSymbolParams params;
}; };
MAKE_REFLECT_STRUCT(Ipc_TextDocumentDocumentSymbol, id, params); MAKE_REFLECT_STRUCT(In_TextDocumentDocumentSymbol, id, params);
REGISTER_IPC_MESSAGE(Ipc_TextDocumentDocumentSymbol); REGISTER_IN_MESSAGE(In_TextDocumentDocumentSymbol);
struct Out_TextDocumentDocumentSymbol struct Out_TextDocumentDocumentSymbol
: public lsOutMessage<Out_TextDocumentDocumentSymbol> { : public lsOutMessage<Out_TextDocumentDocumentSymbol> {
@ -23,9 +24,10 @@ struct Out_TextDocumentDocumentSymbol
}; };
MAKE_REFLECT_STRUCT(Out_TextDocumentDocumentSymbol, jsonrpc, id, result); MAKE_REFLECT_STRUCT(Out_TextDocumentDocumentSymbol, jsonrpc, id, result);
struct TextDocumentDocumentSymbolHandler struct Handler_TextDocumentDocumentSymbol
: BaseMessageHandler<Ipc_TextDocumentDocumentSymbol> { : BaseMessageHandler<In_TextDocumentDocumentSymbol> {
void Run(Ipc_TextDocumentDocumentSymbol* request) override { MethodType GetMethodType() const override { return kMethodType; }
void Run(In_TextDocumentDocumentSymbol* request) override {
Out_TextDocumentDocumentSymbol out; Out_TextDocumentDocumentSymbol out;
out.id = request->id; out.id = request->id;
@ -62,8 +64,8 @@ struct TextDocumentDocumentSymbolHandler
} }
} }
QueueManager::WriteStdout(IpcId::TextDocumentDocumentSymbol, out); QueueManager::WriteStdout(kMethodType, out);
} }
}; };
REGISTER_MESSAGE_HANDLER(TextDocumentDocumentSymbolHandler); REGISTER_MESSAGE_HANDLER(Handler_TextDocumentDocumentSymbol);
} // namespace } // namespace

23
src/messages/text_document_formatting.cc
View File

@ -6,19 +6,19 @@
#include <loguru.hpp> #include <loguru.hpp>
namespace { namespace {
MethodType kMethodType = "textDocument/formatting";
struct Ipc_TextDocumentFormatting struct In_TextDocumentFormatting : public RequestMessage {
: public RequestMessage<Ipc_TextDocumentFormatting> { MethodType GetMethodType() const override { return kMethodType; }
const static IpcId kIpcId = IpcId::TextDocumentFormatting;
struct Params { struct Params {
lsTextDocumentIdentifier textDocument; lsTextDocumentIdentifier textDocument;
lsFormattingOptions options; lsFormattingOptions options;
}; };
Params params; Params params;
}; };
MAKE_REFLECT_STRUCT(Ipc_TextDocumentFormatting::Params, textDocument, options); MAKE_REFLECT_STRUCT(In_TextDocumentFormatting::Params, textDocument, options);
MAKE_REFLECT_STRUCT(Ipc_TextDocumentFormatting, id, params); MAKE_REFLECT_STRUCT(In_TextDocumentFormatting, id, params);
REGISTER_IPC_MESSAGE(Ipc_TextDocumentFormatting); REGISTER_IN_MESSAGE(In_TextDocumentFormatting);
struct Out_TextDocumentFormatting struct Out_TextDocumentFormatting
: public lsOutMessage<Out_TextDocumentFormatting> { : public lsOutMessage<Out_TextDocumentFormatting> {
@ -27,9 +27,10 @@ struct Out_TextDocumentFormatting
}; };
MAKE_REFLECT_STRUCT(Out_TextDocumentFormatting, jsonrpc, id, result); MAKE_REFLECT_STRUCT(Out_TextDocumentFormatting, jsonrpc, id, result);
struct TextDocumentFormattingHandler struct Handler_TextDocumentFormatting
: BaseMessageHandler<Ipc_TextDocumentFormatting> { : BaseMessageHandler<In_TextDocumentFormatting> {
void Run(Ipc_TextDocumentFormatting* request) override { MethodType GetMethodType() const override { return kMethodType; }
void Run(In_TextDocumentFormatting* request) override {
Out_TextDocumentFormatting response; Out_TextDocumentFormatting response;
response.id = request->id; response.id = request->id;
#if USE_CLANG_CXX #if USE_CLANG_CXX
@ -54,8 +55,8 @@ struct TextDocumentFormattingHandler
response.result = {}; response.result = {};
#endif #endif
QueueManager::WriteStdout(IpcId::TextDocumentFormatting, response); QueueManager::WriteStdout(kMethodType, response);
} }
}; };
REGISTER_MESSAGE_HANDLER(TextDocumentFormattingHandler); REGISTER_MESSAGE_HANDLER(Handler_TextDocumentFormatting);
} // namespace } // namespace

18
src/messages/text_document_hover.cc
View File

@ -3,6 +3,7 @@
#include "queue_manager.h" #include "queue_manager.h"
namespace { namespace {
MethodType kMethodType = "textDocument/hover";
std::pair<std::string_view, std::string_view> GetCommentsAndHover( std::pair<std::string_view, std::string_view> GetCommentsAndHover(
QueryDatabase* db, QueryDatabase* db,
@ -41,12 +42,12 @@ std::pair<std::string_view, std::string_view> GetCommentsAndHover(
return {"", ""}; return {"", ""};
} }
struct Ipc_TextDocumentHover : public RequestMessage<Ipc_TextDocumentHover> { struct In_TextDocumentHover : public RequestMessage {
const static IpcId kIpcId = IpcId::TextDocumentHover; MethodType GetMethodType() const override { return kMethodType; }
lsTextDocumentPositionParams params; lsTextDocumentPositionParams params;
}; };
MAKE_REFLECT_STRUCT(Ipc_TextDocumentHover, id, params); MAKE_REFLECT_STRUCT(In_TextDocumentHover, id, params);
REGISTER_IPC_MESSAGE(Ipc_TextDocumentHover); REGISTER_IN_MESSAGE(In_TextDocumentHover);
struct Out_TextDocumentHover : public lsOutMessage<Out_TextDocumentHover> { struct Out_TextDocumentHover : public lsOutMessage<Out_TextDocumentHover> {
struct Result { struct Result {
@ -73,8 +74,9 @@ void Reflect(Writer& visitor, Out_TextDocumentHover& value) {
REFLECT_MEMBER_END(); REFLECT_MEMBER_END();
} }
struct TextDocumentHoverHandler : BaseMessageHandler<Ipc_TextDocumentHover> { struct Handler_TextDocumentHover : BaseMessageHandler<In_TextDocumentHover> {
void Run(Ipc_TextDocumentHover* request) override { MethodType GetMethodType() const override { return kMethodType; }
void Run(In_TextDocumentHover* request) override {
QueryFile* file; QueryFile* file;
if (!FindFileOrFail(db, project, request->id, if (!FindFileOrFail(db, project, request->id,
request->params.textDocument.uri.GetPath(), &file)) { request->params.textDocument.uri.GetPath(), &file)) {
@ -111,8 +113,8 @@ struct TextDocumentHoverHandler : BaseMessageHandler<Ipc_TextDocumentHover> {
} }
} }
QueueManager::WriteStdout(IpcId::TextDocumentHover, out); QueueManager::WriteStdout(kMethodType, out);
} }
}; };
REGISTER_MESSAGE_HANDLER(TextDocumentHoverHandler); REGISTER_MESSAGE_HANDLER(Handler_TextDocumentHover);
} // namespace } // namespace

22
src/messages/text_document_range_formatting.cc
View File

@ -7,6 +7,7 @@
#include <loguru.hpp> #include <loguru.hpp>
namespace { namespace {
MethodType kMethodType = "textDocument/rangeFormatting";
struct lsTextDocumentRangeFormattingParams { struct lsTextDocumentRangeFormattingParams {
lsTextDocumentIdentifier textDocument; lsTextDocumentIdentifier textDocument;
@ -18,13 +19,12 @@ MAKE_REFLECT_STRUCT(lsTextDocumentRangeFormattingParams,
range, range,
options); options);
struct Ipc_TextDocumentRangeFormatting struct In_TextDocumentRangeFormatting : public RequestMessage {
: public RequestMessage<Ipc_TextDocumentRangeFormatting> { MethodType GetMethodType() const override { return kMethodType; }
const static IpcId kIpcId = IpcId::TextDocumentRangeFormatting;
lsTextDocumentRangeFormattingParams params; lsTextDocumentRangeFormattingParams params;
}; };
MAKE_REFLECT_STRUCT(Ipc_TextDocumentRangeFormatting, id, params); MAKE_REFLECT_STRUCT(In_TextDocumentRangeFormatting, id, params);
REGISTER_IPC_MESSAGE(Ipc_TextDocumentRangeFormatting); REGISTER_IN_MESSAGE(In_TextDocumentRangeFormatting);
struct Out_TextDocumentRangeFormatting struct Out_TextDocumentRangeFormatting
: public lsOutMessage<Out_TextDocumentRangeFormatting> { : public lsOutMessage<Out_TextDocumentRangeFormatting> {
@ -33,9 +33,11 @@ struct Out_TextDocumentRangeFormatting
}; };
MAKE_REFLECT_STRUCT(Out_TextDocumentRangeFormatting, jsonrpc, id, result); MAKE_REFLECT_STRUCT(Out_TextDocumentRangeFormatting, jsonrpc, id, result);
struct TextDocumentRangeFormattingHandler struct Handler_TextDocumentRangeFormatting
: BaseMessageHandler<Ipc_TextDocumentRangeFormatting> { : BaseMessageHandler<In_TextDocumentRangeFormatting> {
void Run(Ipc_TextDocumentRangeFormatting* request) override { MethodType GetMethodType() const override { return kMethodType; }
void Run(In_TextDocumentRangeFormatting* request) override {
Out_TextDocumentRangeFormatting response; Out_TextDocumentRangeFormatting response;
response.id = request->id; response.id = request->id;
#if USE_CLANG_CXX #if USE_CLANG_CXX
@ -62,8 +64,8 @@ struct TextDocumentRangeFormattingHandler
response.result = {}; response.result = {};
#endif #endif
QueueManager::WriteStdout(IpcId::TextDocumentRangeFormatting, response); QueueManager::WriteStdout(kMethodType, response);
} }
}; };
REGISTER_MESSAGE_HANDLER(TextDocumentRangeFormattingHandler); REGISTER_MESSAGE_HANDLER(Handler_TextDocumentRangeFormatting);
} // namespace } // namespace

27
src/messages/text_document_references.cc
View File

@ -5,9 +5,10 @@
#include <loguru.hpp> #include <loguru.hpp>
namespace { namespace {
struct Ipc_TextDocumentReferences MethodType kMethodType = "textDocument/references";
: public RequestMessage<Ipc_TextDocumentReferences> {
const static IpcId kIpcId = IpcId::TextDocumentReferences; struct In_TextDocumentReferences : public RequestMessage {
MethodType GetMethodType() const override { return kMethodType; }
struct lsReferenceContext { struct lsReferenceContext {
// Include the declaration of the current symbol. // Include the declaration of the current symbol.
bool includeDeclaration; bool includeDeclaration;
@ -22,15 +23,15 @@ struct Ipc_TextDocumentReferences
Params params; Params params;
}; };
MAKE_REFLECT_STRUCT(Ipc_TextDocumentReferences::lsReferenceContext, MAKE_REFLECT_STRUCT(In_TextDocumentReferences::lsReferenceContext,
includeDeclaration, includeDeclaration,
role); role);
MAKE_REFLECT_STRUCT(Ipc_TextDocumentReferences::Params, MAKE_REFLECT_STRUCT(In_TextDocumentReferences::Params,
textDocument, textDocument,
position, position,
context); context);
MAKE_REFLECT_STRUCT(Ipc_TextDocumentReferences, id, params); MAKE_REFLECT_STRUCT(In_TextDocumentReferences, id, params);
REGISTER_IPC_MESSAGE(Ipc_TextDocumentReferences); REGISTER_IN_MESSAGE(In_TextDocumentReferences);
struct Out_TextDocumentReferences struct Out_TextDocumentReferences
: public lsOutMessage<Out_TextDocumentReferences> { : public lsOutMessage<Out_TextDocumentReferences> {
@ -39,9 +40,11 @@ struct Out_TextDocumentReferences
}; };
MAKE_REFLECT_STRUCT(Out_TextDocumentReferences, jsonrpc, id, result); MAKE_REFLECT_STRUCT(Out_TextDocumentReferences, jsonrpc, id, result);
struct TextDocumentReferencesHandler struct Handler_TextDocumentReferences
: BaseMessageHandler<Ipc_TextDocumentReferences> { : BaseMessageHandler<In_TextDocumentReferences> {
void Run(Ipc_TextDocumentReferences* request) override { MethodType GetMethodType() const override { return kMethodType; }
void Run(In_TextDocumentReferences* request) override {
QueryFile* file; QueryFile* file;
if (!FindFileOrFail(db, project, request->id, if (!FindFileOrFail(db, project, request->id,
request->params.textDocument.uri.GetPath(), &file)) { request->params.textDocument.uri.GetPath(), &file)) {
@ -93,8 +96,8 @@ struct TextDocumentReferencesHandler
if ((int)out.result.size() >= config->xref.maxNum) if ((int)out.result.size() >= config->xref.maxNum)
out.result.resize(config->xref.maxNum); out.result.resize(config->xref.maxNum);
QueueManager::WriteStdout(IpcId::TextDocumentReferences, out); QueueManager::WriteStdout(kMethodType, out);
} }
}; };
REGISTER_MESSAGE_HANDLER(TextDocumentReferencesHandler); REGISTER_MESSAGE_HANDLER(Handler_TextDocumentReferences);
} // namespace } // namespace

20
src/messages/text_document_rename.cc
View File

@ -3,6 +3,7 @@
#include "queue_manager.h" #include "queue_manager.h"
namespace { namespace {
MethodType kMethodType = "textDocument/rename";
lsWorkspaceEdit BuildWorkspaceEdit(QueryDatabase* db, lsWorkspaceEdit BuildWorkspaceEdit(QueryDatabase* db,
WorkingFiles* working_files, WorkingFiles* working_files,
@ -47,8 +48,8 @@ lsWorkspaceEdit BuildWorkspaceEdit(QueryDatabase* db,
return edit; return edit;
} }
struct Ipc_TextDocumentRename : public RequestMessage<Ipc_TextDocumentRename> { struct In_TextDocumentRename : public RequestMessage {
const static IpcId kIpcId = IpcId::TextDocumentRename; MethodType GetMethodType() const override { return kMethodType; }
struct Params { struct Params {
// The document to format. // The document to format.
lsTextDocumentIdentifier textDocument; lsTextDocumentIdentifier textDocument;
@ -63,12 +64,12 @@ struct Ipc_TextDocumentRename : public RequestMessage<Ipc_TextDocumentRename> {
}; };
Params params; Params params;
}; };
MAKE_REFLECT_STRUCT(Ipc_TextDocumentRename::Params, MAKE_REFLECT_STRUCT(In_TextDocumentRename::Params,
textDocument, textDocument,
position, position,
newName); newName);
MAKE_REFLECT_STRUCT(Ipc_TextDocumentRename, id, params); MAKE_REFLECT_STRUCT(In_TextDocumentRename, id, params);
REGISTER_IPC_MESSAGE(Ipc_TextDocumentRename); REGISTER_IN_MESSAGE(In_TextDocumentRename);
struct Out_TextDocumentRename : public lsOutMessage<Out_TextDocumentRename> { struct Out_TextDocumentRename : public lsOutMessage<Out_TextDocumentRename> {
lsRequestId id; lsRequestId id;
@ -76,8 +77,9 @@ struct Out_TextDocumentRename : public lsOutMessage<Out_TextDocumentRename> {
}; };
MAKE_REFLECT_STRUCT(Out_TextDocumentRename, jsonrpc, id, result); MAKE_REFLECT_STRUCT(Out_TextDocumentRename, jsonrpc, id, result);
struct TextDocumentRenameHandler : BaseMessageHandler<Ipc_TextDocumentRename> { struct Handler_TextDocumentRename : BaseMessageHandler<In_TextDocumentRename> {
void Run(Ipc_TextDocumentRename* request) override { MethodType GetMethodType() const override { return kMethodType; }
void Run(In_TextDocumentRename* request) override {
QueryFileId file_id; QueryFileId file_id;
QueryFile* file; QueryFile* file;
if (!FindFileOrFail(db, project, request->id, if (!FindFileOrFail(db, project, request->id,
@ -100,8 +102,8 @@ struct TextDocumentRenameHandler : BaseMessageHandler<Ipc_TextDocumentRename> {
break; break;
} }
QueueManager::WriteStdout(IpcId::TextDocumentRename, out); QueueManager::WriteStdout(kMethodType, out);
} }
}; };
REGISTER_MESSAGE_HANDLER(TextDocumentRenameHandler); REGISTER_MESSAGE_HANDLER(Handler_TextDocumentRename);
} // namespace } // namespace

23
src/messages/text_document_signature_help.cc
View File

@ -7,13 +7,14 @@
#include <stdint.h> #include <stdint.h>
namespace { namespace {
struct Ipc_TextDocumentSignatureHelp MethodType kMethodType = "textDocument/signatureHelp";
: public RequestMessage<Ipc_TextDocumentSignatureHelp> {
const static IpcId kIpcId = IpcId::TextDocumentSignatureHelp; struct In_TextDocumentSignatureHelp : public RequestMessage {
MethodType GetMethodType() const override { return kMethodType; }
lsTextDocumentPositionParams params; lsTextDocumentPositionParams params;
}; };
MAKE_REFLECT_STRUCT(Ipc_TextDocumentSignatureHelp, id, params); MAKE_REFLECT_STRUCT(In_TextDocumentSignatureHelp, id, params);
REGISTER_IPC_MESSAGE(Ipc_TextDocumentSignatureHelp); REGISTER_IN_MESSAGE(In_TextDocumentSignatureHelp);
// Represents a parameter of a callable-signature. A parameter can // Represents a parameter of a callable-signature. A parameter can
// have a label and a doc-comment. // have a label and a doc-comment.
@ -82,11 +83,11 @@ struct Out_TextDocumentSignatureHelp
}; };
MAKE_REFLECT_STRUCT(Out_TextDocumentSignatureHelp, jsonrpc, id, result); MAKE_REFLECT_STRUCT(Out_TextDocumentSignatureHelp, jsonrpc, id, result);
struct TextDocumentSignatureHelpHandler : MessageHandler { struct Handler_TextDocumentSignatureHelp : MessageHandler {
IpcId GetId() const override { return IpcId::TextDocumentSignatureHelp; } MethodType GetMethodType() const override { return kMethodType; }
void Run(std::unique_ptr<BaseIpcMessage> message) override { void Run(std::unique_ptr<BaseIpcMessage> message) override {
auto request = message->As<Ipc_TextDocumentSignatureHelp>(); auto request = static_cast<In_TextDocumentSignatureHelp*>(message.get());
lsTextDocumentPositionParams& params = request->params; lsTextDocumentPositionParams& params = request->params;
WorkingFile* file = WorkingFile* file =
working_files->GetFileByFilename(params.textDocument.uri.GetPath()); working_files->GetFileByFilename(params.textDocument.uri.GetPath());
@ -105,7 +106,7 @@ struct TextDocumentSignatureHelpHandler : MessageHandler {
[this](BaseIpcMessage* message, std::string search, int active_param, [this](BaseIpcMessage* message, std::string search, int active_param,
const std::vector<lsCompletionItem>& results, const std::vector<lsCompletionItem>& results,
bool is_cached_result) { bool is_cached_result) {
auto msg = message->As<Ipc_TextDocumentSignatureHelp>(); auto msg = static_cast<In_TextDocumentSignatureHelp*>(message);
Out_TextDocumentSignatureHelp out; Out_TextDocumentSignatureHelp out;
out.id = msg->id; out.id = msg->id;
@ -142,7 +143,7 @@ struct TextDocumentSignatureHelpHandler : MessageHandler {
out.result.activeParameter = active_param; out.result.activeParameter = active_param;
Timer timer; Timer timer;
QueueManager::WriteStdout(IpcId::TextDocumentSignatureHelp, out); QueueManager::WriteStdout(kMethodType, out);
if (!is_cached_result) { if (!is_cached_result) {
signature_cache->WithLock([&]() { signature_cache->WithLock([&]() {
@ -168,5 +169,5 @@ struct TextDocumentSignatureHelpHandler : MessageHandler {
} }
} }
}; };
REGISTER_MESSAGE_HANDLER(TextDocumentSignatureHelpHandler); REGISTER_MESSAGE_HANDLER(Handler_TextDocumentSignatureHelp);
} // namespace } // namespace

21
src/messages/text_document_type_definition.cc
View File

@ -3,14 +3,14 @@
#include "queue_manager.h" #include "queue_manager.h"
namespace { namespace {
MethodType kMethodType = "textDocument/typeDefinition";
struct Ipc_TextDocumentTypeDefinition struct In_TextDocumentTypeDefinition : public RequestMessage {
: public RequestMessage<Ipc_TextDocumentTypeDefinition> { MethodType GetMethodType() const override { return kMethodType; }
const static IpcId kIpcId = IpcId::TextDocumentTypeDefinition;
lsTextDocumentPositionParams params; lsTextDocumentPositionParams params;
}; };
MAKE_REFLECT_STRUCT(Ipc_TextDocumentTypeDefinition, id, params); MAKE_REFLECT_STRUCT(In_TextDocumentTypeDefinition, id, params);
REGISTER_IPC_MESSAGE(Ipc_TextDocumentTypeDefinition); REGISTER_IN_MESSAGE(In_TextDocumentTypeDefinition);
struct Out_TextDocumentTypeDefinition struct Out_TextDocumentTypeDefinition
: public lsOutMessage<Out_TextDocumentTypeDefinition> { : public lsOutMessage<Out_TextDocumentTypeDefinition> {
@ -19,9 +19,10 @@ struct Out_TextDocumentTypeDefinition
}; };
MAKE_REFLECT_STRUCT(Out_TextDocumentTypeDefinition, jsonrpc, id, result); MAKE_REFLECT_STRUCT(Out_TextDocumentTypeDefinition, jsonrpc, id, result);
struct TextDocumentTypeDefinitionHandler struct Handler_TextDocumentTypeDefinition
: BaseMessageHandler<Ipc_TextDocumentTypeDefinition> { : BaseMessageHandler<In_TextDocumentTypeDefinition> {
void Run(Ipc_TextDocumentTypeDefinition* request) override { MethodType GetMethodType() const override { return kMethodType; }
void Run(In_TextDocumentTypeDefinition* request) override {
QueryFile* file; QueryFile* file;
if (!FindFileOrFail(db, project, request->id, if (!FindFileOrFail(db, project, request->id,
request->params.textDocument.uri.GetPath(), &file, request->params.textDocument.uri.GetPath(), &file,
@ -59,9 +60,9 @@ struct TextDocumentTypeDefinitionHandler
} }
} }
QueueManager::WriteStdout(IpcId::TextDocumentTypeDefinition, out); QueueManager::WriteStdout(kMethodType, out);
} }
}; };
REGISTER_MESSAGE_HANDLER(TextDocumentTypeDefinitionHandler); REGISTER_MESSAGE_HANDLER(Handler_TextDocumentTypeDefinition);
} // namespace } // namespace

20
src/messages/workspace_did_change_configuration.cc
View File

@ -9,22 +9,24 @@
#include <loguru.hpp> #include <loguru.hpp>
namespace { namespace {
MethodType kMethodType = "workspace/didChangeConfiguration";
struct lsDidChangeConfigurationParams { struct lsDidChangeConfigurationParams {
bool placeholder; bool placeholder;
}; };
MAKE_REFLECT_STRUCT(lsDidChangeConfigurationParams, placeholder); MAKE_REFLECT_STRUCT(lsDidChangeConfigurationParams, placeholder);
struct Ipc_WorkspaceDidChangeConfiguration struct In_WorkspaceDidChangeConfiguration : public NotificationMessage {
: public NotificationMessage<Ipc_WorkspaceDidChangeConfiguration> { MethodType GetMethodType() const override { return kMethodType; }
const static IpcId kIpcId = IpcId::WorkspaceDidChangeConfiguration;
lsDidChangeConfigurationParams params; lsDidChangeConfigurationParams params;
}; };
MAKE_REFLECT_STRUCT(Ipc_WorkspaceDidChangeConfiguration, params); MAKE_REFLECT_STRUCT(In_WorkspaceDidChangeConfiguration, params);
REGISTER_IPC_MESSAGE(Ipc_WorkspaceDidChangeConfiguration); REGISTER_IN_MESSAGE(In_WorkspaceDidChangeConfiguration);
struct WorkspaceDidChangeConfigurationHandler struct Handler_WorkspaceDidChangeConfiguration
: BaseMessageHandler<Ipc_WorkspaceDidChangeConfiguration> { : BaseMessageHandler<In_WorkspaceDidChangeConfiguration> {
void Run(Ipc_WorkspaceDidChangeConfiguration* request) override { MethodType GetMethodType() const override { return kMethodType; }
void Run(In_WorkspaceDidChangeConfiguration* request) override {
Timer time; Timer time;
project->Load(config, config->projectRoot); project->Load(config, config->projectRoot);
time.ResetAndPrint("[perf] Loaded compilation entries (" + time.ResetAndPrint("[perf] Loaded compilation entries (" +
@ -40,5 +42,5 @@ struct WorkspaceDidChangeConfigurationHandler
LOG_S(INFO) << "Flushed all clang complete sessions"; LOG_S(INFO) << "Flushed all clang complete sessions";
} }
}; };
REGISTER_MESSAGE_HANDLER(WorkspaceDidChangeConfigurationHandler); REGISTER_MESSAGE_HANDLER(Handler_WorkspaceDidChangeConfiguration);
} // namespace } // namespace

20
src/messages/workspace_did_change_watched_files.cc
View File

@ -8,6 +8,8 @@
#include <loguru/loguru.hpp> #include <loguru/loguru.hpp>
namespace { namespace {
MethodType kMethodType = "workspace/didChangeWatchedFiles";
enum class lsFileChangeType { enum class lsFileChangeType {
Created = 1, Created = 1,
Changed = 2, Changed = 2,
@ -26,17 +28,17 @@ struct lsDidChangeWatchedFilesParams {
}; };
MAKE_REFLECT_STRUCT(lsDidChangeWatchedFilesParams, changes); MAKE_REFLECT_STRUCT(lsDidChangeWatchedFilesParams, changes);
struct Ipc_WorkspaceDidChangeWatchedFiles struct In_WorkspaceDidChangeWatchedFiles : public NotificationMessage {
: public NotificationMessage<Ipc_WorkspaceDidChangeWatchedFiles> { MethodType GetMethodType() const override { return kMethodType; }
const static IpcId kIpcId = IpcId::WorkspaceDidChangeWatchedFiles;
lsDidChangeWatchedFilesParams params; lsDidChangeWatchedFilesParams params;
}; };
MAKE_REFLECT_STRUCT(Ipc_WorkspaceDidChangeWatchedFiles, params); MAKE_REFLECT_STRUCT(In_WorkspaceDidChangeWatchedFiles, params);
REGISTER_IPC_MESSAGE(Ipc_WorkspaceDidChangeWatchedFiles); REGISTER_IN_MESSAGE(In_WorkspaceDidChangeWatchedFiles);
struct WorkspaceDidChangeWatchedFilesHandler struct Handler_WorkspaceDidChangeWatchedFiles
: BaseMessageHandler<Ipc_WorkspaceDidChangeWatchedFiles> { : BaseMessageHandler<In_WorkspaceDidChangeWatchedFiles> {
void Run(Ipc_WorkspaceDidChangeWatchedFiles* request) override { MethodType GetMethodType() const override { return kMethodType; }
void Run(In_WorkspaceDidChangeWatchedFiles* request) override {
for (lsFileEvent& event : request->params.changes) { for (lsFileEvent& event : request->params.changes) {
std::string path = event.uri.GetPath(); std::string path = event.uri.GetPath();
auto it = project->absolute_path_to_entry_index_.find(path); auto it = project->absolute_path_to_entry_index_.find(path);
@ -69,5 +71,5 @@ struct WorkspaceDidChangeWatchedFilesHandler
} }
} }
}; };
REGISTER_MESSAGE_HANDLER(WorkspaceDidChangeWatchedFilesHandler); REGISTER_MESSAGE_HANDLER(Handler_WorkspaceDidChangeWatchedFiles);
} // namespace } // namespace

21
src/messages/workspace_execute_command.cc
View File

@ -4,14 +4,14 @@
#include "queue_manager.h" #include "queue_manager.h"
namespace { namespace {
MethodType kMethodType = "workspace/executeCommand";
struct Ipc_WorkspaceExecuteCommand struct In_WorkspaceExecuteCommand : public RequestMessage {
: public RequestMessage<Ipc_WorkspaceExecuteCommand> { MethodType GetMethodType() const override { return kMethodType; }
const static IpcId kIpcId = IpcId::WorkspaceExecuteCommand;
lsCommand<lsCodeLensCommandArguments> params; lsCommand<lsCodeLensCommandArguments> params;
}; };
MAKE_REFLECT_STRUCT(Ipc_WorkspaceExecuteCommand, id, params); MAKE_REFLECT_STRUCT(In_WorkspaceExecuteCommand, id, params);
REGISTER_IPC_MESSAGE(Ipc_WorkspaceExecuteCommand); REGISTER_IN_MESSAGE(In_WorkspaceExecuteCommand);
struct Out_WorkspaceExecuteCommand struct Out_WorkspaceExecuteCommand
: public lsOutMessage<Out_WorkspaceExecuteCommand> { : public lsOutMessage<Out_WorkspaceExecuteCommand> {
@ -28,9 +28,10 @@ void Reflect(Writer& visitor, Out_WorkspaceExecuteCommand& value) {
REFLECT_MEMBER_END(); REFLECT_MEMBER_END();
} }
struct WorkspaceExecuteCommandHandler struct Handler_WorkspaceExecuteCommand
: BaseMessageHandler<Ipc_WorkspaceExecuteCommand> { : BaseMessageHandler<In_WorkspaceExecuteCommand> {
void Run(Ipc_WorkspaceExecuteCommand* request) override { MethodType GetMethodType() const override { return kMethodType; }
void Run(In_WorkspaceExecuteCommand* request) override {
const auto& params = request->params; const auto& params = request->params;
Out_WorkspaceExecuteCommand out; Out_WorkspaceExecuteCommand out;
out.id = request->id; out.id = request->id;
@ -41,9 +42,9 @@ struct WorkspaceExecuteCommandHandler
out.result = params.arguments.locations; out.result = params.arguments.locations;
} }
QueueManager::WriteStdout(IpcId::WorkspaceExecuteCommand, out); QueueManager::WriteStdout(kMethodType, out);
} }
}; };
REGISTER_MESSAGE_HANDLER(WorkspaceExecuteCommandHandler); REGISTER_MESSAGE_HANDLER(Handler_WorkspaceExecuteCommand);
} // namespace } // namespace

20
src/messages/workspace_symbol.cc
View File

@ -12,6 +12,7 @@
#include <functional> #include <functional>
namespace { namespace {
MethodType kMethodType = "workspace/symbol";
// Lookup |symbol| in |db| and insert the value into |result|. // Lookup |symbol| in |db| and insert the value into |result|.
bool InsertSymbolIntoResult(QueryDatabase* db, bool InsertSymbolIntoResult(QueryDatabase* db,
@ -42,16 +43,16 @@ bool InsertSymbolIntoResult(QueryDatabase* db,
return true; return true;
} }
struct Ipc_WorkspaceSymbol : public RequestMessage<Ipc_WorkspaceSymbol> { struct In_WorkspaceSymbol : public RequestMessage {
const static IpcId kIpcId = IpcId::WorkspaceSymbol; MethodType GetMethodType() const override { return kMethodType; }
struct Params { struct Params {
std::string query; std::string query;
}; };
Params params; Params params;
}; };
MAKE_REFLECT_STRUCT(Ipc_WorkspaceSymbol::Params, query); MAKE_REFLECT_STRUCT(In_WorkspaceSymbol::Params, query);
MAKE_REFLECT_STRUCT(Ipc_WorkspaceSymbol, id, params); MAKE_REFLECT_STRUCT(In_WorkspaceSymbol, id, params);
REGISTER_IPC_MESSAGE(Ipc_WorkspaceSymbol); REGISTER_IN_MESSAGE(In_WorkspaceSymbol);
struct Out_WorkspaceSymbol : public lsOutMessage<Out_WorkspaceSymbol> { struct Out_WorkspaceSymbol : public lsOutMessage<Out_WorkspaceSymbol> {
lsRequestId id; lsRequestId id;
@ -61,8 +62,9 @@ MAKE_REFLECT_STRUCT(Out_WorkspaceSymbol, jsonrpc, id, result);
///// Fuzzy matching ///// Fuzzy matching
struct WorkspaceSymbolHandler : BaseMessageHandler<Ipc_WorkspaceSymbol> { struct Handler_WorkspaceSymbol : BaseMessageHandler<In_WorkspaceSymbol> {
void Run(Ipc_WorkspaceSymbol* request) override { MethodType GetMethodType() const override { return kMethodType; }
void Run(In_WorkspaceSymbol* request) override {
Out_WorkspaceSymbol out; Out_WorkspaceSymbol out;
out.id = request->id; out.id = request->id;
@ -151,8 +153,8 @@ struct WorkspaceSymbolHandler : BaseMessageHandler<Ipc_WorkspaceSymbol> {
LOG_S(INFO) << "[querydb] Found " << out.result.size() LOG_S(INFO) << "[querydb] Found " << out.result.size()
<< " results for query " << query; << " results for query " << query;
QueueManager::WriteStdout(IpcId::WorkspaceSymbol, out); QueueManager::WriteStdout(kMethodType, out);
} }
}; };
REGISTER_MESSAGE_HANDLER(WorkspaceSymbolHandler); REGISTER_MESSAGE_HANDLER(Handler_WorkspaceSymbol);
} // namespace } // namespace

60
src/methods.inc
View File

@ -1,60 +0,0 @@
// General
CASE(Initialize, "initialize")
CASE(Shutdown, "shutdown")
CASE(CodeLensResolve, "codeLens/resolve")
CASE(TextDocumentCodeAction, "textDocument/codeAction")
CASE(TextDocumentCodeLens, "textDocument/codeLens")
CASE(TextDocumentCompletion, "textDocument/completion")
CASE(TextDocumentDefinition, "textDocument/definition")
CASE(TextDocumentDidChange, "textDocument/didChange")
CASE(TextDocumentDidClose, "textDocument/didClose")
CASE(TextDocumentDidOpen, "textDocument/didOpen")
CASE(TextDocumentDidSave, "textDocument/didSave")
CASE(TextDocumentDocumentHighlight, "textDocument/documentHighlight")
CASE(TextDocumentDocumentLink, "textDocument/documentLink")
CASE(TextDocumentDocumentSymbol, "textDocument/documentSymbol")
CASE(TextDocumentFormatting, "textDocument/formatting")
CASE(TextDocumentHover, "textDocument/hover")
CASE(TextDocumentOnTypeFormatting, "textDocument/onTypeFormatting")
CASE(TextDocumentPublishDiagnostics, "textDocument/publishDiagnostics")
CASE(TextDocumentRangeFormatting, "textDocument/rangeFormatting")
CASE(TextDocumentReferences, "textDocument/references")
CASE(TextDocumentRename, "textDocument/rename")
CASE(TextDocumentSignatureHelp, "textDocument/signatureHelp")
CASE(TextDocumentTypeDefinition, "textDocument/typeDefinition")
CASE(WorkspaceDidChangeConfiguration, "workspace/didChangeConfiguration")
CASE(WorkspaceDidChangeWatchedFiles, "workspace/didChangeWatchedFiles")
CASE(WorkspaceExecuteCommand, "workspace/executeCommand")
CASE(WorkspaceSymbol, "workspace/symbol")
// Notification extensions
CASE(CqueryTextDocumentDidView, "$cquery/textDocumentDidView")
CASE(CqueryPublishInactiveRegions, "$cquery/publishInactiveRegions")
CASE(CqueryPublishSemanticHighlighting, "$cquery/publishSemanticHighlighting")
// Request extensions
CASE(CqueryFileInfo, "$cquery/fileInfo")
CASE(CqueryFreshenIndex, "$cquery/freshenIndex")
CASE(CqueryCallHierarchy, "$cquery/callHierarchy")
CASE(CqueryInheritanceHierarchy, "$cquery/inheritanceHierarchy")
CASE(CqueryMemberHierarchy, "$cquery/memberHierarchy")
// Cross reference extensions.
// Show all variables of a type.
CASE(CqueryVars, "$cquery/vars")
// Show all callers of a function.
CASE(CqueryCallers, "$cquery/callers")
// Show base types/method.
CASE(CqueryBase, "$cquery/base")
// Show all derived types/methods.
CASE(CqueryDerived, "$cquery/derived")
// Show random definition.
CASE(CqueryRandom, "$cquery/random")
// Messages for testing.
// Index the given file contents.
CASE(CqueryIndexFile, "$cquery/indexFile")
// Wait until all cquery threads are idle.
CASE(CqueryWait, "$cquery/wait")

4
src/queue_manager.cc
View File

@ -63,13 +63,13 @@ void QueueManager::Init(MultiQueueWaiter* querydb_waiter,
} }
// static // static
void QueueManager::WriteStdout(IpcId id, lsBaseOutMessage& response) { void QueueManager::WriteStdout(MethodType method, lsBaseOutMessage& response) {
std::ostringstream sstream; std::ostringstream sstream;
response.Write(sstream); response.Write(sstream);
Stdout_Request out; Stdout_Request out;
out.content = sstream.str(); out.content = sstream.str();
out.id = id; out.method = method;
instance()->for_stdout.PushBack(std::move(out)); instance()->for_stdout.PushBack(std::move(out));
} }

4
src/queue_manager.h
View File

@ -11,7 +11,7 @@ struct ICacheManager;
struct lsBaseOutMessage; struct lsBaseOutMessage;
struct Stdout_Request { struct Stdout_Request {
IpcId id; MethodType method;
std::string content; std::string content;
}; };
@ -86,7 +86,7 @@ class QueueManager {
static void Init(MultiQueueWaiter* querydb_waiter, static void Init(MultiQueueWaiter* querydb_waiter,
MultiQueueWaiter* indexer_waiter, MultiQueueWaiter* indexer_waiter,
MultiQueueWaiter* stdout_waiter); MultiQueueWaiter* stdout_waiter);
static void WriteStdout(IpcId id, lsBaseOutMessage& response); static void WriteStdout(MethodType method, lsBaseOutMessage& response);
bool HasWork(); bool HasWork();