ccls/src/command_line.cc

874 lines
28 KiB
C++
Raw Normal View History

2017-03-25 20:15:00 +00:00
// TODO: cleanup includes
#include "code_completion.h"
2017-02-25 23:59:09 +00:00
#include "compilation_database_loader.h"
#include "indexer.h"
#include "query.h"
2017-03-05 02:16:23 +00:00
#include "language_server_api.h"
#include "project.h"
2017-03-25 20:27:28 +00:00
#include "platform.h"
2017-03-10 07:06:01 +00:00
#include "test.h"
2017-03-25 20:15:00 +00:00
#include "timer.h"
#include "threaded_queue.h"
#include "typed_bidi_message_queue.h"
#include "working_files.h"
2017-03-05 02:16:23 +00:00
2017-03-25 20:27:28 +00:00
#include <doctest/doctest.h>
#include <rapidjson/istreamwrapper.h>
#include <rapidjson/ostreamwrapper.h>
#include <iostream>
#include <string>
#include <unordered_map>
#include <thread>
#include <vector>
2017-02-25 23:59:09 +00:00
2017-03-25 20:27:28 +00:00
namespace {
2017-03-15 04:59:05 +00:00
const char* kIpcLanguageClientName = "language_client";
const int kNumIndexers = 8 - 1;
2017-03-28 02:28:45 +00:00
const int kQueueSizeBytes = 1024 * 8;
2017-03-25 20:27:28 +00:00
}
2017-03-25 19:18:25 +00:00
struct IndexTranslationUnitRequest {
std::string path;
std::vector<std::string> args;
};
struct IndexTranslationUnitResponse {
IndexUpdate update;
explicit IndexTranslationUnitResponse(IndexUpdate& update) : update(update) {}
};
// TODO: Rename TypedBidiMessageQueue to IpcTransport?
2017-03-25 21:57:06 +00:00
using IpcMessageQueue = TypedBidiMessageQueue<IpcId, BaseIpcMessage>;
2017-03-25 19:18:25 +00:00
using IndexRequestQueue = ThreadedQueue<IndexTranslationUnitRequest>;
using IndexResponseQueue = ThreadedQueue<IndexTranslationUnitResponse>;
template<typename TMessage>
void SendMessage(IpcMessageQueue& t, MessageQueue* destination, TMessage& message) {
2017-03-25 21:57:06 +00:00
t.SendMessage(destination, TMessage::kIpcId, message);
2017-03-25 19:18:25 +00:00
}
2017-03-15 04:59:05 +00:00
2017-03-17 07:58:41 +00:00
std::unordered_map<std::string, std::string> ParseOptions(int argc,
2017-03-25 19:18:25 +00:00
char** argv) {
2017-02-25 23:59:09 +00:00
std::unordered_map<std::string, std::string> output;
std::string previous_arg;
for (int i = 1; i < argc; ++i) {
std::string arg = argv[i];
if (arg[0] != '-') {
if (previous_arg.size() == 0) {
2017-03-17 07:58:41 +00:00
std::cerr << "Invalid arguments; switches must start with -"
2017-03-25 19:18:25 +00:00
<< std::endl;
2017-02-25 23:59:09 +00:00
exit(1);
}
output[previous_arg] = arg;
previous_arg = "";
2017-03-25 19:18:25 +00:00
}
else {
2017-02-25 23:59:09 +00:00
output[arg] = "";
previous_arg = arg;
}
}
return output;
}
2017-03-17 07:58:41 +00:00
bool HasOption(const std::unordered_map<std::string, std::string>& options,
2017-03-25 19:18:25 +00:00
const std::string& option) {
2017-02-25 23:59:09 +00:00
return options.find(option) != options.end();
}
2017-03-05 19:48:05 +00:00
2017-03-14 08:33:39 +00:00
std::string Join(const std::vector<std::string>& elements, std::string sep) {
bool first = true;
std::string result;
for (const auto& element : elements) {
if (!first)
result += ", ";
first = false;
result += element;
}
return result;
}
2017-03-05 19:48:05 +00:00
2017-03-25 21:45:49 +00:00
template<typename T>
void SendOutMessageToClient(IpcMessageQueue* queue, T& response) {
std::ostringstream sstream;
response.Write(sstream);
Ipc_Cout out;
out.content = sstream.str();
2017-03-25 21:57:06 +00:00
queue->SendMessage(&queue->for_client, Ipc_Cout::kIpcId, out);
2017-03-25 19:18:25 +00:00
}
2017-03-14 08:33:39 +00:00
2017-03-25 19:18:25 +00:00
template<typename T>
void RegisterId(IpcMessageQueue* t) {
2017-03-25 21:57:06 +00:00
t->RegisterId(T::kIpcId,
2017-03-25 21:02:45 +00:00
[](Writer& visitor, BaseIpcMessage& message) {
2017-03-25 19:18:25 +00:00
T& m = static_cast<T&>(message);
Reflect(visitor, m);
}, [](Reader& visitor) {
auto m = MakeUnique<T>();
Reflect(visitor, *m);
return m;
});
2017-03-14 08:33:39 +00:00
}
2017-03-25 19:18:25 +00:00
std::unique_ptr<IpcMessageQueue> BuildIpcMessageQueue(const std::string& name, size_t buffer_size) {
auto ipc = MakeUnique<IpcMessageQueue>(name, buffer_size);
2017-03-25 21:02:45 +00:00
RegisterId<Ipc_CancelRequest>(ipc.get());
RegisterId<Ipc_InitializeRequest>(ipc.get());
RegisterId<Ipc_InitializedNotification>(ipc.get());
RegisterId<Ipc_TextDocumentDidOpen>(ipc.get());
RegisterId<Ipc_TextDocumentDidChange>(ipc.get());
RegisterId<Ipc_TextDocumentDidClose>(ipc.get());
RegisterId<Ipc_TextDocumentComplete>(ipc.get());
2017-03-25 21:02:45 +00:00
RegisterId<Ipc_TextDocumentDocumentSymbol>(ipc.get());
RegisterId<Ipc_TextDocumentCodeLens>(ipc.get());
RegisterId<Ipc_CodeLensResolve>(ipc.get());
RegisterId<Ipc_WorkspaceSymbol>(ipc.get());
RegisterId<Ipc_Quit>(ipc.get());
RegisterId<Ipc_IsAlive>(ipc.get());
RegisterId<Ipc_OpenProject>(ipc.get());
RegisterId<Ipc_Cout>(ipc.get());
2017-03-25 19:18:25 +00:00
return ipc;
}
void RegisterMessageTypes() {
2017-03-25 21:02:45 +00:00
MessageRegistry::instance()->Register<Ipc_CancelRequest>();
MessageRegistry::instance()->Register<Ipc_InitializeRequest>();
MessageRegistry::instance()->Register<Ipc_InitializedNotification>();
MessageRegistry::instance()->Register<Ipc_TextDocumentDidOpen>();
MessageRegistry::instance()->Register<Ipc_TextDocumentDidChange>();
MessageRegistry::instance()->Register<Ipc_TextDocumentDidClose>();
MessageRegistry::instance()->Register<Ipc_TextDocumentComplete>();
2017-03-25 21:02:45 +00:00
MessageRegistry::instance()->Register<Ipc_TextDocumentDocumentSymbol>();
MessageRegistry::instance()->Register<Ipc_TextDocumentCodeLens>();
MessageRegistry::instance()->Register<Ipc_CodeLensResolve>();
MessageRegistry::instance()->Register<Ipc_WorkspaceSymbol>();
2017-03-12 00:36:00 +00:00
}
2017-03-25 19:18:25 +00:00
void IndexMain(IndexRequestQueue* requests, IndexResponseQueue* responses) {
while (true) {
// Try to get a request. If there isn't one, sleep for a little while.
optional<IndexTranslationUnitRequest> request = requests->TryDequeue();
if (!request) {
// TODO: use CV to wakeup?
std::this_thread::sleep_for(std::chrono::milliseconds(500));
continue;
2017-03-14 08:33:39 +00:00
}
2017-03-25 19:18:25 +00:00
// Parse request and send a response.
std::cerr << "Parsing file " << request->path << " with args "
<< Join(request->args, ", ") << std::endl;
Timer time;
IndexedFile file = Parse(request->path, request->args);
2017-03-31 04:13:58 +00:00
time.ResetAndPrint("Parsing/indexing");
2017-03-25 19:18:25 +00:00
IndexUpdate update(file);
IndexTranslationUnitResponse response(update);
2017-03-31 04:13:58 +00:00
time.ResetAndPrint("Creating index update/response");
2017-03-25 19:18:25 +00:00
responses->Enqueue(response);
2017-03-31 04:13:58 +00:00
time.ResetAndPrint("Sending update to server");
2017-03-14 08:33:39 +00:00
}
}
2017-03-05 19:48:05 +00:00
2017-03-15 07:14:44 +00:00
QueryableFile* FindFile(QueryableDatabase* db, const std::string& filename) {
2017-03-17 07:58:41 +00:00
// std::cerr << "Wanted file " << msg->document << std::endl;
2017-03-15 07:14:44 +00:00
// TODO: hashmap lookup.
for (auto& file : db->files) {
2017-03-17 07:58:41 +00:00
// std::cerr << " - Have file " << file.file_id << std::endl;
2017-03-15 07:14:44 +00:00
if (file.file_id == filename) {
//std::cerr << "Found file " << filename << std::endl;
2017-03-15 07:14:44 +00:00
return &file;
}
}
2017-03-15 04:59:05 +00:00
2017-03-15 07:14:44 +00:00
std::cerr << "Unable to find file " << filename << std::endl;
return nullptr;
}
2017-03-15 04:59:05 +00:00
2017-03-16 07:36:49 +00:00
lsLocation GetLsLocation(const QueryableLocation& location) {
2017-03-15 07:14:44 +00:00
return lsLocation(
2017-03-25 19:18:25 +00:00
lsDocumentUri::FromPath(location.path),
lsRange(lsPosition(location.line - 1, location.column - 1)));
2017-03-15 07:14:44 +00:00
}
2017-03-15 04:59:05 +00:00
2017-03-17 07:58:41 +00:00
void AddCodeLens(std::vector<TCodeLens>* result,
2017-03-25 19:18:25 +00:00
QueryableLocation loc,
const std::vector<QueryableLocation>& uses,
bool only_interesting,
const char* singular,
const char* plural) {
2017-03-16 07:36:49 +00:00
TCodeLens code_lens;
2017-03-31 04:13:58 +00:00
code_lens.range.start.line = loc.line - 1;
code_lens.range.start.character = loc.column - 1;
// TODO: store range information.
2017-03-16 07:36:49 +00:00
code_lens.range.end.line = code_lens.range.start.line;
code_lens.range.end.character = code_lens.range.start.character;
code_lens.command = lsCommand<lsCodeLensCommandArguments>();
code_lens.command->command = "superindex.showReferences";
code_lens.command->arguments.uri = lsDocumentUri::FromPath(loc.path);
code_lens.command->arguments.position = code_lens.range.start;
// Add unique uses.
std::unordered_set<lsLocation> unique_uses;
for (const QueryableLocation& use : uses) {
2017-03-17 07:58:41 +00:00
if (only_interesting && !use.interesting)
continue;
2017-03-16 07:36:49 +00:00
unique_uses.insert(GetLsLocation(use));
}
2017-03-17 07:58:41 +00:00
code_lens.command->arguments.locations.assign(unique_uses.begin(),
2017-03-25 19:18:25 +00:00
unique_uses.end());
2017-03-16 07:36:49 +00:00
// User visible label
int num_usages = unique_uses.size();
code_lens.command->title = std::to_string(num_usages) + " ";
if (num_usages == 1)
code_lens.command->title += singular;
else
code_lens.command->title += plural;
if (unique_uses.size() > 0)
result->push_back(code_lens);
}
2017-03-17 07:58:41 +00:00
void AddCodeLens(std::vector<TCodeLens>* result,
2017-03-25 19:18:25 +00:00
QueryableLocation loc,
const std::vector<UsrRef>& uses,
bool only_interesting,
const char* singular,
const char* plural) {
2017-03-16 07:36:49 +00:00
std::vector<QueryableLocation> uses0;
uses0.reserve(uses.size());
for (const UsrRef& use : uses)
uses0.push_back(use.loc);
AddCodeLens(result, loc, uses0, only_interesting, singular, plural);
}
2017-03-17 07:58:41 +00:00
void AddCodeLens(std::vector<TCodeLens>* result,
2017-03-25 19:18:25 +00:00
QueryableDatabase* db,
QueryableLocation loc,
const std::vector<Usr>& usrs,
bool only_interesting,
const char* singular,
const char* plural) {
2017-03-16 07:36:49 +00:00
std::vector<QueryableLocation> uses0;
uses0.reserve(usrs.size());
for (const Usr& usr : usrs) {
SymbolIdx symbol = db->usr_to_symbol[usr];
switch (symbol.kind) {
2017-03-25 19:18:25 +00:00
case SymbolKind::Type: {
QueryableTypeDef* def = &db->types[symbol.idx];
if (def->def.definition)
uses0.push_back(def->def.definition.value());
break;
}
case SymbolKind::Func: {
QueryableFuncDef* def = &db->funcs[symbol.idx];
if (def->def.definition)
uses0.push_back(def->def.definition.value());
break;
}
case SymbolKind::Var: {
QueryableVarDef* def = &db->vars[symbol.idx];
if (def->def.definition)
uses0.push_back(def->def.definition.value());
break;
}
case SymbolKind::File:
case SymbolKind::Invalid: {
assert(false && "unexpected");
break;
}
2017-03-16 07:36:49 +00:00
}
}
AddCodeLens(result, loc, uses0, only_interesting, singular, plural);
}
2017-03-25 19:18:25 +00:00
void QueryDbMainLoop(
QueryableDatabase* db,
IpcMessageQueue* language_client,
IndexRequestQueue* index_requests,
IndexResponseQueue* index_responses,
Project* project,
WorkingFiles* working_files,
CompletionManager* completion_manager) {
2017-03-25 21:02:45 +00:00
std::vector<std::unique_ptr<BaseIpcMessage>> messages = language_client->GetMessages(&language_client->for_server);
2017-03-05 19:48:05 +00:00
for (auto& message : messages) {
2017-03-29 06:33:38 +00:00
std::cerr << "[querydb] Processing message " << static_cast<int>(message->method_id) << std::endl;
2017-03-05 19:48:05 +00:00
2017-03-25 19:18:25 +00:00
switch (message->method_id) {
2017-03-25 21:57:06 +00:00
case IpcId::Quit: {
2017-03-25 19:18:25 +00:00
std::cerr << "Got quit message (exiting)" << std::endl;
exit(0);
break;
}
2017-03-05 19:48:05 +00:00
2017-03-25 21:57:06 +00:00
case IpcId::IsAlive: {
2017-03-25 21:02:45 +00:00
Ipc_IsAlive response;
2017-03-25 19:18:25 +00:00
language_client->SendMessage(&language_client->for_client, response.method_id, response);
break;
}
2017-03-15 07:14:44 +00:00
2017-03-25 21:57:06 +00:00
case IpcId::OpenProject: {
2017-03-25 21:02:45 +00:00
Ipc_OpenProject* msg = static_cast<Ipc_OpenProject*>(message.get());
2017-03-25 19:18:25 +00:00
std::string path = msg->project_path;
project->entries = LoadCompilationEntriesFromDirectory(path);
2017-03-28 01:04:37 +00:00
std::cerr << "Loaded compilation entries (" << project->entries.size() << " files)" << std::endl;
2017-03-28 01:47:12 +00:00
//for (int i = 0; i < 10; ++i)
//std::cerr << project->entries[i].filename << std::endl;
for (int i = 0; i < project->entries.size(); ++i) {
const CompilationEntry& entry = project->entries[i];
std::string filepath = entry.filename;
std::cerr << "[" << i << "/" << (project->entries.size() - 1)
2017-03-25 19:18:25 +00:00
<< "] Dispatching index request for file " << filepath
<< std::endl;
IndexTranslationUnitRequest request;
request.path = filepath;
request.args = entry.args;
index_requests->Enqueue(request);
2017-03-15 07:14:44 +00:00
}
2017-03-25 19:18:25 +00:00
std::cerr << "Done" << std::endl;
break;
}
2017-03-15 07:14:44 +00:00
case IpcId::TextDocumentDidOpen: {
auto msg = static_cast<Ipc_TextDocumentDidOpen*>(message.get());
//std::cerr << "Opening " << msg->params.textDocument.uri.GetPath() << std::endl;
working_files->OnOpen(msg->params);
break;
}
case IpcId::TextDocumentDidChange: {
auto msg = static_cast<Ipc_TextDocumentDidChange*>(message.get());
working_files->OnChange(msg->params);
//std::cerr << "Changing " << msg->params.textDocument.uri.GetPath() << std::endl;
break;
}
case IpcId::TextDocumentDidClose: {
auto msg = static_cast<Ipc_TextDocumentDidClose*>(message.get());
std::cerr << "Closing " << msg->params.textDocument.uri.GetPath() << std::endl;
//working_files->OnClose(msg->params);
break;
}
case IpcId::TextDocumentCompletion: {
auto msg = static_cast<Ipc_TextDocumentComplete*>(message.get());
Out_TextDocumentComplete response;
response.id = msg->id;
response.result.isIncomplete = false;
response.result.items = completion_manager->CodeComplete(msg->params);
Timer timer;
response.Write(std::cout);
2017-03-31 04:13:58 +00:00
timer.ResetAndPrint("Writing completion results");
//SendOutMessageToClient(language_client, response);
break;
}
2017-03-25 21:57:06 +00:00
case IpcId::TextDocumentDocumentSymbol: {
2017-03-25 21:02:45 +00:00
auto msg = static_cast<Ipc_TextDocumentDocumentSymbol*>(message.get());
2017-03-25 19:18:25 +00:00
2017-03-25 21:02:45 +00:00
Out_TextDocumentDocumentSymbol response;
2017-03-25 19:18:25 +00:00
response.id = msg->id;
QueryableFile* file = FindFile(db, msg->params.textDocument.uri.GetPath());
2017-03-29 06:33:38 +00:00
if (!file) {
std::cerr << "Unable to find file " << msg->params.textDocument.uri.GetPath() << std::endl;
break;
}
2017-03-25 19:18:25 +00:00
2017-03-29 06:33:38 +00:00
std::cerr << "File outline size is " << file->outline.size() << std::endl;
for (UsrRef ref : file->outline) {
SymbolIdx symbol = db->usr_to_symbol[ref.usr];
lsSymbolInformation info;
info.location.range.start.line =
ref.loc.line - 1; // TODO: cleanup indexer to negate by 1.
info.location.range.start.character =
ref.loc.column - 1; // TODO: cleanup indexer to negate by 1.
// TODO: store range information.
info.location.range.end.line = info.location.range.start.line;
info.location.range.end.character =
info.location.range.start.character;
// TODO: cleanup namespace/naming so there is only one SymbolKind.
switch (symbol.kind) {
case SymbolKind::Type: {
QueryableTypeDef& def = db->types[symbol.idx];
info.name = def.def.qualified_name;
info.kind = lsSymbolKind::Class;
break;
}
case SymbolKind::Func: {
QueryableFuncDef& def = db->funcs[symbol.idx];
info.name = def.def.qualified_name;
if (def.def.declaring_type.has_value()) {
info.kind = lsSymbolKind::Method;
Usr declaring = def.def.declaring_type.value();
info.containerName =
db->types[db->usr_to_symbol[declaring].idx]
.def.qualified_name;
2017-03-25 19:18:25 +00:00
}
2017-03-29 06:33:38 +00:00
else {
info.kind = lsSymbolKind::Function;
2017-03-25 19:18:25 +00:00
}
2017-03-29 06:33:38 +00:00
break;
}
case SymbolKind::Var: {
QueryableVarDef& def = db->vars[symbol.idx];
info.name = def.def.qualified_name;
info.kind = lsSymbolKind::Variable;
break;
}
case SymbolKind::File:
case SymbolKind::Invalid: {
assert(false && "unexpected");
break;
2017-03-25 19:18:25 +00:00
}
2017-03-29 06:33:38 +00:00
};
response.result.push_back(info);
2017-03-17 07:58:41 +00:00
}
2017-03-06 08:48:51 +00:00
2017-03-25 19:18:25 +00:00
SendOutMessageToClient(language_client, response);
break;
}
2017-03-25 21:57:06 +00:00
case IpcId::TextDocumentCodeLens: {
2017-03-25 21:02:45 +00:00
auto msg = static_cast<Ipc_TextDocumentCodeLens*>(message.get());
2017-03-25 19:18:25 +00:00
2017-03-25 21:02:45 +00:00
Out_TextDocumentCodeLens response;
2017-03-25 19:18:25 +00:00
response.id = msg->id;
lsDocumentUri file_as_uri = msg->params.textDocument.uri;
QueryableFile* file = FindFile(db, file_as_uri.GetPath());
2017-03-29 06:33:38 +00:00
if (!file) {
std::cerr << "Unable to find file " << msg->params.textDocument.uri.GetPath() << std::endl;
break;
}
for (UsrRef ref : file->outline) {
SymbolIdx symbol = db->usr_to_symbol[ref.usr];
switch (symbol.kind) {
case SymbolKind::Type: {
QueryableTypeDef& def = db->types[symbol.idx];
AddCodeLens(&response.result, ref.loc, def.uses,
true /*only_interesting*/, "reference",
"references");
AddCodeLens(&response.result, db, ref.loc, def.derived,
false /*only_interesting*/, "derived", "derived");
break;
}
case SymbolKind::Func: {
QueryableFuncDef& def = db->funcs[symbol.idx];
AddCodeLens(&response.result, ref.loc, def.uses,
false /*only_interesting*/, "reference",
"references");
AddCodeLens(&response.result, ref.loc, def.callers,
false /*only_interesting*/, "caller", "callers");
AddCodeLens(&response.result, ref.loc, def.def.callees,
false /*only_interesting*/, "callee", "callees");
AddCodeLens(&response.result, db, ref.loc, def.derived,
false /*only_interesting*/, "derived", "derived");
break;
}
case SymbolKind::Var: {
QueryableVarDef& def = db->vars[symbol.idx];
AddCodeLens(&response.result, ref.loc, def.uses,
false /*only_interesting*/, "reference",
"references");
break;
}
case SymbolKind::File:
case SymbolKind::Invalid: {
assert(false && "unexpected");
break;
2017-03-17 07:58:41 +00:00
}
2017-03-29 06:33:38 +00:00
};
2017-03-17 07:58:41 +00:00
}
2017-03-06 08:48:51 +00:00
2017-03-25 19:18:25 +00:00
SendOutMessageToClient(language_client, response);
break;
}
2017-03-25 21:57:06 +00:00
case IpcId::WorkspaceSymbol: {
2017-03-25 21:02:45 +00:00
auto msg = static_cast<Ipc_WorkspaceSymbol*>(message.get());
2017-03-25 19:18:25 +00:00
2017-03-25 21:02:45 +00:00
Out_WorkspaceSymbol response;
2017-03-25 19:18:25 +00:00
response.id = msg->id;
std::cerr << "- Considering " << db->qualified_names.size()
<< " candidates " << std::endl;
std::string query = msg->params.query;
for (int i = 0; i < db->qualified_names.size(); ++i) {
const std::string& name = db->qualified_names[i];
// std::cerr << "- Considering " << name << std::endl;
if (name.find(query) != std::string::npos) {
lsSymbolInformation info;
info.name = name;
SymbolIdx symbol = db->symbols[i];
// TODO: dedup this code w/ above (ie, add ctor to convert symbol to
// SymbolInformation)
switch (symbol.kind) {
// TODO: file
case SymbolKind::Type: {
QueryableTypeDef& def = db->types[symbol.idx];
info.name = def.def.qualified_name;
info.kind = lsSymbolKind::Class;
if (def.def.definition.has_value()) {
info.location.uri.SetPath(def.def.definition->path);
info.location.range.start.line = def.def.definition->line - 1;
info.location.range.start.character =
def.def.definition->column - 1;
}
break;
2017-03-17 07:58:41 +00:00
}
2017-03-25 19:18:25 +00:00
case SymbolKind::Func: {
QueryableFuncDef& def = db->funcs[symbol.idx];
info.name = def.def.qualified_name;
if (def.def.declaring_type.has_value()) {
info.kind = lsSymbolKind::Method;
Usr declaring = def.def.declaring_type.value();
info.containerName =
db->types[db->usr_to_symbol[declaring].idx]
.def.qualified_name;
}
else {
info.kind = lsSymbolKind::Function;
}
if (def.def.definition.has_value()) {
info.location.uri.SetPath(def.def.definition->path);
info.location.range.start.line = def.def.definition->line - 1;
info.location.range.start.character =
def.def.definition->column - 1;
}
break;
}
case SymbolKind::Var: {
QueryableVarDef& def = db->vars[symbol.idx];
info.name = def.def.qualified_name;
info.kind = lsSymbolKind::Variable;
if (def.def.definition.has_value()) {
info.location.uri.SetPath(def.def.definition->path);
info.location.range.start.line = def.def.definition->line - 1;
info.location.range.start.character =
def.def.definition->column - 1;
}
break;
}
case SymbolKind::Invalid: {
assert(false && "unexpected");
break;
}
};
2017-03-06 08:48:51 +00:00
2017-03-25 19:18:25 +00:00
// TODO: store range information.
info.location.range.end.line = info.location.range.start.line;
info.location.range.end.character =
info.location.range.start.character;
2017-03-15 04:59:05 +00:00
2017-03-25 19:18:25 +00:00
response.result.push_back(info);
}
2017-03-17 07:58:41 +00:00
}
2017-03-25 19:18:25 +00:00
SendOutMessageToClient(language_client, response);
break;
}
default: {
std::cerr << "Unhandled IPC message with kind "
<< static_cast<int>(message->method_id) << std::endl;
exit(1);
}
2017-03-15 04:59:05 +00:00
}
}
2017-03-25 19:18:25 +00:00
// TODO: consider rate-limiting and checking for IPC messages so we don't block
// requests / we can serve partial requests.
while (true) {
optional<IndexTranslationUnitResponse> response = index_responses->TryDequeue();
if (!response)
break;
2017-03-15 04:59:05 +00:00
2017-03-25 19:18:25 +00:00
Timer time;
db->ApplyIndexUpdate(&response->update);
2017-03-31 04:13:58 +00:00
time.ResetAndPrint("Applying index update");
2017-03-05 02:16:23 +00:00
}
}
2017-03-15 04:59:05 +00:00
void QueryDbMain() {
std::cerr << "Running QueryDb" << std::endl;
2017-03-25 19:18:25 +00:00
// Create queues.
std::unique_ptr<IpcMessageQueue> ipc = BuildIpcMessageQueue(kIpcLanguageClientName, kQueueSizeBytes);
IndexRequestQueue index_request_queue;
IndexResponseQueue index_response_queue;
Project project;
WorkingFiles working_files;
CompletionManager completion_manager(&project, &working_files);
2017-03-25 19:18:25 +00:00
// Start indexer threads.
2017-03-15 04:59:05 +00:00
for (int i = 0; i < kNumIndexers; ++i) {
2017-03-25 19:18:25 +00:00
new std::thread([&]() {
IndexMain(&index_request_queue, &index_response_queue);
});
2017-03-15 04:59:05 +00:00
}
2017-03-25 19:18:25 +00:00
// Run query db main loop.
QueryableDatabase db;
2017-03-15 04:59:05 +00:00
while (true) {
QueryDbMainLoop(&db, ipc.get(), &index_request_queue, &index_response_queue, &project, &working_files, &completion_manager);
2017-03-15 04:59:05 +00:00
std::this_thread::sleep_for(std::chrono::milliseconds(10));
}
}
2017-03-05 19:48:05 +00:00
// TODO: global lock on stderr output.
// Separate thread whose only job is to read from stdin and
// dispatch read commands to the actual indexer program. This
// cannot be done on the main thread because reading from std::cin
// blocks.
//
// |ipc| is connected to a server.
2017-03-25 19:18:25 +00:00
void LanguageServerStdinLoop(IpcMessageQueue* ipc) {
2017-03-05 02:16:23 +00:00
while (true) {
2017-03-25 21:57:06 +00:00
std::unique_ptr<BaseIpcMessage> message = MessageRegistry::instance()->ReadMessageFromStdin();
2017-03-05 02:16:23 +00:00
// Message parsing can fail if we don't recognize the method.
if (!message)
continue;
//std::cerr << "[info]: Got message of type "
// << IpcIdToString(message->method_id) << std::endl;
2017-03-05 02:16:23 +00:00
switch (message->method_id) {
2017-03-25 19:18:25 +00:00
// TODO: For simplicitly lets just proxy the initialize request like
// all other requests so that stdin loop thread becomes super simple.
2017-03-25 21:57:06 +00:00
case IpcId::Initialize: {
2017-03-25 21:02:45 +00:00
auto request = static_cast<Ipc_InitializeRequest*>(message.get());
2017-03-25 19:18:25 +00:00
if (request->params.rootUri) {
std::string project_path = request->params.rootUri->GetPath();
std::cerr << "Initialize in directory " << project_path
<< " with uri " << request->params.rootUri->raw_uri
<< std::endl;
2017-03-25 21:02:45 +00:00
Ipc_OpenProject open_project;
2017-03-25 19:18:25 +00:00
open_project.project_path = project_path;
2017-03-25 21:57:06 +00:00
ipc->SendMessage(&ipc->for_server, Ipc_OpenProject::kIpcId, open_project);
2017-03-17 07:58:41 +00:00
}
2017-03-06 08:48:51 +00:00
// TODO: query request->params.capabilities.textDocument and support only things
// the client supports.
2017-03-25 19:18:25 +00:00
auto response = Out_InitializeResponse();
response.id = request->id;
//response.result.capabilities.textDocumentSync = lsTextDocumentSyncOptions();
//response.result.capabilities.textDocumentSync->openClose = true;
//response.result.capabilities.textDocumentSync->change = lsTextDocumentSyncKind::Full;
//response.result.capabilities.textDocumentSync->willSave = true;
//response.result.capabilities.textDocumentSync->willSaveWaitUntil = true;
response.result.capabilities.textDocumentSync = lsTextDocumentSyncKind::Full; // TODO: use incremental at some point
response.result.capabilities.completionProvider = lsCompletionOptions();
response.result.capabilities.completionProvider->resolveProvider = false;
2017-03-29 06:33:38 +00:00
response.result.capabilities.completionProvider->triggerCharacters = { ".", "::", "->" };
2017-03-25 19:18:25 +00:00
response.result.capabilities.codeLensProvider = lsCodeLensOptions();
response.result.capabilities.codeLensProvider->resolveProvider = false;
response.result.capabilities.documentSymbolProvider = true;
2017-03-25 19:18:25 +00:00
response.result.capabilities.workspaceSymbolProvider = true;
response.Write(std::cerr);
2017-03-25 21:45:49 +00:00
response.Write(std::cout);
2017-03-25 19:18:25 +00:00
break;
}
2017-03-15 07:14:44 +00:00
case IpcId::Initialized: {
// TODO: don't send output until we get this notification
break;
}
case IpcId::CancelRequest: {
// TODO: support cancellation
break;
}
case IpcId::TextDocumentDidOpen:
case IpcId::TextDocumentDidChange:
case IpcId::TextDocumentDidClose: {
case IpcId::TextDocumentCompletion:
2017-03-25 21:57:06 +00:00
case IpcId::TextDocumentDocumentSymbol:
case IpcId::TextDocumentCodeLens:
case IpcId::WorkspaceSymbol:
2017-03-29 06:33:38 +00:00
std::cerr << "Spending message " << (int)message->method_id << std::endl;
2017-03-25 19:18:25 +00:00
ipc->SendMessage(&ipc->for_server, message->method_id, *message.get());
break;
}
default: {
std::cerr << "Unhandled IPC message with kind "
<< static_cast<int>(message->method_id) << std::endl;
exit(1);
}
2017-03-03 08:12:11 +00:00
}
}
}
2017-03-25 19:18:25 +00:00
void LanguageServerMainLoop(IpcMessageQueue* ipc) {
2017-03-25 21:02:45 +00:00
std::vector<std::unique_ptr<BaseIpcMessage>> messages = ipc->GetMessages(&ipc->for_client);
2017-03-05 19:48:05 +00:00
for (auto& message : messages) {
2017-03-25 19:18:25 +00:00
switch (message->method_id) {
2017-03-25 21:57:06 +00:00
case IpcId::Quit: {
2017-03-25 19:18:25 +00:00
std::cerr << "Got quit message (exiting)" << std::endl;
exit(0);
break;
}
2017-03-06 08:48:51 +00:00
2017-03-25 21:57:06 +00:00
case IpcId::Cout: {
2017-03-25 21:02:45 +00:00
auto msg = static_cast<Ipc_Cout*>(message.get());
2017-03-25 19:18:25 +00:00
std::cout << msg->content;
std::cout.flush();
break;
}
2017-03-06 08:48:51 +00:00
2017-03-25 19:18:25 +00:00
default: {
std::cerr << "Unhandled IPC message with kind "
<< static_cast<int>(message->method_id) << std::endl;
exit(1);
}
2017-03-12 00:36:00 +00:00
}
2017-03-05 19:48:05 +00:00
}
}
2017-03-25 19:18:25 +00:00
bool IsQueryDbProcessRunning(IpcMessageQueue* ipc) {
// Emit an alive check. Sleep so the server has time to respond.
2017-03-25 21:02:45 +00:00
Ipc_IsAlive check_alive;
2017-03-25 19:18:25 +00:00
SendMessage(*ipc, &ipc->for_server, check_alive);
2017-03-04 01:45:20 +00:00
// TODO: Tune this value or make it configurable.
2017-03-16 07:36:49 +00:00
std::this_thread::sleep_for(std::chrono::milliseconds(100));
// Check if we got an IsAlive message back.
2017-03-25 21:02:45 +00:00
std::vector<std::unique_ptr<BaseIpcMessage>> messages = ipc->GetMessages(&ipc->for_client);
for (auto& message : messages) {
2017-03-25 21:57:06 +00:00
if (IpcId::IsAlive == message->method_id)
2017-03-25 19:18:25 +00:00
return true;
}
2017-03-25 19:18:25 +00:00
return false;
}
2017-03-05 02:16:23 +00:00
2017-03-25 19:18:25 +00:00
void LanguageServerMain(std::string process_name) {
std::unique_ptr<IpcMessageQueue> ipc = BuildIpcMessageQueue(kIpcLanguageClientName, kQueueSizeBytes);
// Discard any left-over messages from previous runs.
ipc->GetMessages(&ipc->for_client);
2017-03-14 08:33:39 +00:00
2017-03-25 19:18:25 +00:00
bool has_server = IsQueryDbProcessRunning(ipc.get());
// No server is running. Start it in-process. If the user wants to run the
// server out of process they have to start it themselves.
2017-03-05 19:48:05 +00:00
if (!has_server) {
2017-03-25 19:18:25 +00:00
new std::thread(&QueryDbMain);
2017-03-05 19:48:05 +00:00
}
2017-03-05 02:16:23 +00:00
2017-03-14 06:30:41 +00:00
// Run language client.
2017-03-25 19:18:25 +00:00
new std::thread(&LanguageServerStdinLoop, ipc.get());
2017-03-14 06:30:41 +00:00
while (true) {
2017-03-25 19:18:25 +00:00
LanguageServerMainLoop(ipc.get());
2017-03-14 08:33:39 +00:00
std::this_thread::sleep_for(std::chrono::milliseconds(10));
2017-03-05 19:48:05 +00:00
}
2017-03-16 07:36:49 +00:00
}
2017-03-03 08:12:11 +00:00
2017-03-25 01:28:09 +00:00
int main(int argc, char** argv) {
2017-03-15 04:59:05 +00:00
bool loop = false;
while (loop)
std::this_thread::sleep_for(std::chrono::milliseconds(10));
2017-03-03 08:12:11 +00:00
2017-03-25 20:27:28 +00:00
PlatformInit();
2017-03-25 19:18:25 +00:00
RegisterMessageTypes();
2017-03-15 04:59:05 +00:00
2017-03-17 07:58:41 +00:00
// if (argc == 1) {
2017-03-16 07:36:49 +00:00
// QueryDbMain();
// return 0;
//}
2017-03-25 19:18:25 +00:00
std::unordered_map<std::string, std::string> options =
ParseOptions(argc, argv);
if (argc == 1 || HasOption(options, "--test")) {
2017-03-17 23:45:10 +00:00
doctest::Context context;
context.applyCommandLine(argc, argv);
int res = context.run();
if (context.shouldExit())
2017-03-25 19:18:25 +00:00
return res;
2017-03-17 23:45:10 +00:00
2017-03-25 23:58:11 +00:00
RunTests();
2017-03-15 04:59:05 +00:00
return 0;
}
2017-03-25 19:18:25 +00:00
else if (options.find("--help") != options.end()) {
std::cout << R"help(clang-querydb help:
clang-querydb is a low-latency C++ language server.
General:
--help Print this help information.
--language-server
Run as a language server. The language server will look for
an existing querydb process, otherwise it will run querydb
in-process. This implements the language server spec.
--querydb Run the querydb. The querydb stores the program index and
serves index request tasks.
--test Run tests. Does nothing if test support is not compiled in.
Configuration:
When opening up a directory, clang-querydb will look for a
compile_commands.json file emitted by your preferred build system. If not
present, clang-querydb will use a recursive directory listing instead.
Command line flags can be provided by adding a "clang_args" file in the
top-level directory. Each line in that file is a separate argument.
)help";
exit(0);
}
else if (HasOption(options, "--language-server")) {
2017-03-05 19:48:05 +00:00
std::cerr << "Running language server" << std::endl;
LanguageServerMain(argv[0]);
return 0;
2017-02-25 23:59:09 +00:00
}
2017-03-05 19:48:05 +00:00
else if (HasOption(options, "--querydb")) {
std::cerr << "Running querydb" << std::endl;
2017-03-25 19:18:25 +00:00
QueryDbMain();
2017-03-05 19:48:05 +00:00
return 0;
2017-02-25 23:59:09 +00:00
}
2017-03-25 19:18:25 +00:00
else {
2017-03-05 19:48:05 +00:00
std::cerr << "Running language server" << std::endl;
LanguageServerMain(argv[0]);
return 0;
2017-02-25 23:59:09 +00:00
}
2017-03-05 19:48:05 +00:00
return 1;
2017-02-25 23:59:09 +00:00
}