Zengtudor/ccls
1
0
Fork 0
mirror of https://github.com/MaskRay/ccls.git synced 2025-02-21 16:09:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Cleanup completion logging. Also don't mark isIncomplete for completion results as aggressively.

Browse Source
This commit is contained in:
Jacob Dufault 2017-09-21 19:45:17 -07:00
parent 772f547065
commit 5704ef5077
2 changed files with 18 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
src/clang_complete.cc
View File

@ -65,18 +65,12 @@ int GetCompletionPriority(const CXCompletionString& str,
int priority = clang_getCompletionPriority(str); int priority = clang_getCompletionPriority(str);
if (result_kind == CXCursor_Destructor) { if (result_kind == CXCursor_Destructor) {
priority *= 100; priority *= 100;
// std::cerr << "Bumping[destructor] " << ls_completion_item.label <<
// std::endl;
} }
if (result_kind == CXCursor_ConversionFunction || if (result_kind == CXCursor_ConversionFunction ||
(result_kind == CXCursor_CXXMethod && StartsWith(label, "operator"))) { (result_kind == CXCursor_CXXMethod && StartsWith(label, "operator"))) {
// std::cerr << "Bumping[conversion] " << ls_completion_item.label <<
// std::endl;
priority *= 100; priority *= 100;
} }
if (clang_getCompletionAvailability(str) != CXAvailability_Available) { if (clang_getCompletionAvailability(str) != CXAvailability_Available) {
// std::cerr << "Bumping[notavailable] " << ls_completion_item.label <<
// std::endl;
priority *= 100; priority *= 100;
} }
return priority; return priority;
@ -101,6 +95,9 @@ bool IsCallKind(CXCursorKind kind) {
lsCompletionItemKind GetCompletionKind(CXCursorKind cursor_kind) { lsCompletionItemKind GetCompletionKind(CXCursorKind cursor_kind) {
switch (cursor_kind) { switch (cursor_kind) {
case CXCursor_UnexposedDecl:
return lsCompletionItemKind::Text;
case CXCursor_ObjCInstanceMethodDecl: case CXCursor_ObjCInstanceMethodDecl:
case CXCursor_CXXMethod: case CXCursor_CXXMethod:
return lsCompletionItemKind::Method; return lsCompletionItemKind::Method;
@ -161,8 +158,7 @@ lsCompletionItemKind GetCompletionKind(CXCursorKind cursor_kind) {
return lsCompletionItemKind::Text; return lsCompletionItemKind::Text;
default: default:
std::cerr << "[complete] Unhandled completion kind " << cursor_kind LOG_S(WARNING) << "Unhandled completion kind " << cursor_kind;
<< std::endl;
return lsCompletionItemKind::Text; return lsCompletionItemKind::Text;
} }
} }
@ -299,12 +295,10 @@ void EnsureDocumentParsed(ClangCompleteManager* manager,
std::vector<CXUnsavedFile> unsaved = session->working_files->AsUnsavedFiles(); std::vector<CXUnsavedFile> unsaved = session->working_files->AsUnsavedFiles();
std::cerr << "[complete] Creating completion session with arguments " LOG_S(INFO) << "Creating completion session with arguments "
<< StringJoin(args) << std::endl; << StringJoin(args);
*tu = MakeUnique<clang::TranslationUnit>(index, session->file.filename, args, *tu = MakeUnique<clang::TranslationUnit>(index, session->file.filename, args,
unsaved, Flags()); unsaved, Flags());
std::cerr << "[complete] Done creating active; did_fail=" << (*tu)->did_fail
<< std::endl;
// Build diagnostics. // Build diagnostics.
if (manager->config_->diagnosticsOnParse && !(*tu)->did_fail) { if (manager->config_->diagnosticsOnParse && !(*tu)->did_fail) {
@ -350,8 +344,6 @@ void CompletionParseMain(ClangCompleteManager* completion_manager) {
// under the mutex. // under the mutex.
session->tu_last_parsed_at = std::chrono::high_resolution_clock::now(); session->tu_last_parsed_at = std::chrono::high_resolution_clock::now();
std::lock_guard<std::mutex> lock(session->tu_lock); std::lock_guard<std::mutex> lock(session->tu_lock);
std::cerr << "[completion] Swapping completion session for " << request.path
<< std::endl;
session->tu = std::move(parsing); session->tu = std::move(parsing);
} }
} }
@ -380,28 +372,19 @@ void CompletionQueryMain(ClangCompleteManager* completion_manager) {
unsigned line = request->position->line + 1; unsigned line = request->position->line + 1;
unsigned column = request->position->character + 1; unsigned column = request->position->character + 1;
std::cerr << "[complete] Completing at " << line << ":" << column
<< std::endl;
timer.ResetAndPrint("[complete] Fetching unsaved files");
timer.Reset(); timer.Reset();
unsigned const kCompleteOptions = unsigned const kCompleteOptions =
CXCodeComplete_IncludeMacros | CXCodeComplete_IncludeBriefComments; CXCodeComplete_IncludeMacros | CXCodeComplete_IncludeBriefComments;
CXCodeCompleteResults* cx_results = clang_codeCompleteAt( CXCodeCompleteResults* cx_results = clang_codeCompleteAt(
session->tu->cx_tu, session->file.filename.c_str(), line, column, session->tu->cx_tu, session->file.filename.c_str(), line, column,
unsaved.data(), (unsigned)unsaved.size(), kCompleteOptions); unsaved.data(), (unsigned)unsaved.size(), kCompleteOptions);
timer.ResetAndPrint("[complete] clangCodeCompleteAt");
if (!cx_results) { if (!cx_results) {
timer.ResetAndPrint("[complete] Code completion failed");
if (request->on_complete) if (request->on_complete)
request->on_complete({}, false /*is_cached_result*/); request->on_complete({}, false /*is_cached_result*/);
continue; continue;
} }
timer.ResetAndPrint("[complete] clangCodeCompleteAt");
std::cerr << "[complete] Got " << cx_results->NumResults << " results"
<< std::endl;
{ {
if (request->on_complete) { if (request->on_complete) {
NonElidedVector<lsCompletionItem> ls_result; NonElidedVector<lsCompletionItem> ls_result;
@ -446,7 +429,6 @@ void CompletionQueryMain(ClangCompleteManager* completion_manager) {
" completion results"); " completion results");
request->on_complete(ls_result, false /*is_cached_result*/); request->on_complete(ls_result, false /*is_cached_result*/);
timer.ResetAndPrint("[complete] Running user-given completion func");
} }
} }
@ -486,16 +468,9 @@ CompletionSession::CompletionSession(const Project::Entry& file,
WorkingFiles* working_files) WorkingFiles* working_files)
: file(file), : file(file),
working_files(working_files), working_files(working_files),
index(0 /*excludeDeclarationsFromPCH*/, 0 /*displayDiagnostics*/) { index(0 /*excludeDeclarationsFromPCH*/, 0 /*displayDiagnostics*/) {}
std::cerr << "[complete] CompletionSession::CompletionSession() for "
<< file.filename << std::endl;
}
CompletionSession::~CompletionSession() { CompletionSession::~CompletionSession() {}
std::cerr << "[complete] CompletionSession::~CompletionSession() for "
<< file.filename << std::endl;
// EmitBacktrace();
}
LruSessionCache::LruSessionCache(int max_entries) : max_entries_(max_entries) {} LruSessionCache::LruSessionCache(int max_entries) : max_entries_(max_entries) {}
@ -594,8 +569,6 @@ void ClangCompleteManager::NotifyView(const std::string& filename) {
if (view_sessions_.TryGetEntry(filename)) if (view_sessions_.TryGetEntry(filename))
return; return;
std::cerr << "[complete] Creating new edit code completion session for "
<< filename << std::endl;
view_sessions_.InsertEntry(std::make_shared<CompletionSession>( view_sessions_.InsertEntry(std::make_shared<CompletionSession>(
project_->FindCompilationEntryForFile(filename), working_files_)); project_->FindCompilationEntryForFile(filename), working_files_));
parse_requests_.Enqueue(ParseRequest(filename)); parse_requests_.Enqueue(ParseRequest(filename));
@ -618,8 +591,6 @@ void ClangCompleteManager::NotifyEdit(const std::string& filename) {
if (session) { if (session) {
edit_sessions_.InsertEntry(session); edit_sessions_.InsertEntry(session);
} else { } else {
std::cerr << "[complete] Creating new edit code completion session for "
<< filename << std::endl;
edit_sessions_.InsertEntry(std::make_shared<CompletionSession>( edit_sessions_.InsertEntry(std::make_shared<CompletionSession>(
project_->FindCompilationEntryForFile(filename), working_files_)); project_->FindCompilationEntryForFile(filename), working_files_));
parse_requests_.PriorityEnqueue(ParseRequest(filename)); parse_requests_.PriorityEnqueue(ParseRequest(filename));
@ -634,8 +605,6 @@ void ClangCompleteManager::NotifySave(const std::string& filename) {
std::lock_guard<std::mutex> lock(sessions_lock_); std::lock_guard<std::mutex> lock(sessions_lock_);
if (!edit_sessions_.TryGetEntry(filename)) { if (!edit_sessions_.TryGetEntry(filename)) {
std::cerr << "[complete] Creating new edit code completion session for "
<< filename << std::endl;
edit_sessions_.InsertEntry(std::make_shared<CompletionSession>( edit_sessions_.InsertEntry(std::make_shared<CompletionSession>(
project_->FindCompilationEntryForFile(filename), working_files_)); project_->FindCompilationEntryForFile(filename), working_files_));
} }

48
src/command_line.cc
View File

@ -416,8 +416,6 @@ void FilterCompletionResponse(Out_TextDocumentComplete* complete_response,
const size_t kMaxResultSize = 100u; const size_t kMaxResultSize = 100u;
if (complete_response->result.items.size() > kMaxResultSize) { if (complete_response->result.items.size() > kMaxResultSize) {
complete_response->result.isIncomplete = true;
if (complete_text.empty()) { if (complete_text.empty()) {
complete_response->result.items.resize(kMaxResultSize); complete_response->result.items.resize(kMaxResultSize);
} else { } else {
@ -454,6 +452,15 @@ void FilterCompletionResponse(Out_TextDocumentComplete* complete_response,
} }
complete_response->result.items = filtered_result; complete_response->result.items = filtered_result;
// Assuming the client does not support out-of-order completion (ie, ao
// matches against oa), our filtering is guaranteed to contain any
// potential matches, so the completion is only incomplete if we have the
// max number of emitted matches.
if (complete_response->result.items.size() >= kMaxResultSize) {
LOG_S(INFO) << "Marking completion results as incomplete";
complete_response->result.isIncomplete = true;
}
} }
} }
} }
@ -1743,7 +1750,6 @@ bool QueryDbMainLoop(Config* config,
if (ShouldRunIncludeCompletion(buffer_line)) { if (ShouldRunIncludeCompletion(buffer_line)) {
Out_TextDocumentComplete complete_response; Out_TextDocumentComplete complete_response;
complete_response.id = msg->id; complete_response.id = msg->id;
complete_response.result.isIncomplete = false;
{ {
std::unique_lock<std::mutex> lock( std::unique_lock<std::mutex> lock(
@ -1765,9 +1771,6 @@ bool QueryDbMainLoop(Config* config,
} }
} }
LOG_S(INFO) << "[complete] Returning "
<< complete_response.result.items.size()
<< " include completions";
FilterCompletionResponse(&complete_response, buffer_line); FilterCompletionResponse(&complete_response, buffer_line);
ipc->SendOutMessageToClient(IpcId::TextDocumentCompletion, ipc->SendOutMessageToClient(IpcId::TextDocumentCompletion,
complete_response); complete_response);
@ -1780,9 +1783,6 @@ bool QueryDbMainLoop(Config* config,
&existing_completion); &existing_completion);
} }
LOG_S(INFO) << "[complete] Got existing completion "
<< existing_completion;
ClangCompleteManager::OnComplete callback = std::bind( ClangCompleteManager::OnComplete callback = std::bind(
[working_files, global_code_complete_cache, [working_files, global_code_complete_cache,
non_global_code_complete_cache, is_global_completion, non_global_code_complete_cache, is_global_completion,
@ -1792,7 +1792,6 @@ bool QueryDbMainLoop(Config* config,
Out_TextDocumentComplete complete_response; Out_TextDocumentComplete complete_response;
complete_response.id = msg->id; complete_response.id = msg->id;
complete_response.result.isIncomplete = false;
complete_response.result.items = results; complete_response.result.items = results;
// Emit completion results. // Emit completion results.
@ -1807,26 +1806,14 @@ bool QueryDbMainLoop(Config* config,
if (is_global_completion) { if (is_global_completion) {
global_code_complete_cache->WithLock([&]() { global_code_complete_cache->WithLock([&]() {
global_code_complete_cache->cached_path_ = path; global_code_complete_cache->cached_path_ = path;
LOG_S(INFO) << "[complete] Updating "
"global_code_complete_cache->cached_"
"results [0]";
global_code_complete_cache->cached_results_ = results; global_code_complete_cache->cached_results_ = results;
LOG_S(INFO) << "[complete] DONE Updating "
"global_code_complete_cache->cached_"
"results [0]";
}); });
} else { } else {
non_global_code_complete_cache->WithLock([&]() { non_global_code_complete_cache->WithLock([&]() {
non_global_code_complete_cache->cached_path_ = path; non_global_code_complete_cache->cached_path_ = path;
non_global_code_complete_cache non_global_code_complete_cache
->cached_completion_position_ = msg->params.position; ->cached_completion_position_ = msg->params.position;
LOG_S(INFO) << "[complete] Updating "
"non_global_code_complete_cache->cached_"
"results [1]";
non_global_code_complete_cache->cached_results_ = results; non_global_code_complete_cache->cached_results_ = results;
LOG_S(INFO) << "[complete] DONE Updating "
"non_global_code_complete_cache->cached_"
"results [1]";
}); });
} }
} }
@ -1841,10 +1828,6 @@ bool QueryDbMainLoop(Config* config,
!global_code_complete_cache->cached_results_.empty(); !global_code_complete_cache->cached_results_.empty();
}); });
if (is_cache_match) { if (is_cache_match) {
LOG_S(INFO) << "[complete] Early-returning cached global "
"completion results at "
<< msg->params.position.ToString();
ClangCompleteManager::OnComplete freshen_global = ClangCompleteManager::OnComplete freshen_global =
[global_code_complete_cache]( [global_code_complete_cache](
NonElidedVector<lsCompletionItem> results, NonElidedVector<lsCompletionItem> results,
@ -1852,16 +1835,10 @@ bool QueryDbMainLoop(Config* config,
assert(!is_cached_result); assert(!is_cached_result);
LOG_S(INFO) << "[complete] Updating "
"global_code_complete_cache->cached_results "
"[2]";
// note: path is updated in the normal completion handler. // note: path is updated in the normal completion handler.
global_code_complete_cache->WithLock([&]() { global_code_complete_cache->WithLock([&]() {
global_code_complete_cache->cached_results_ = results; global_code_complete_cache->cached_results_ = results;
}); });
LOG_S(INFO) << "[complete] DONE Updating "
"global_code_complete_cache->cached_results "
"[2]";
}; };
global_code_complete_cache->WithLock([&]() { global_code_complete_cache->WithLock([&]() {
@ -1871,8 +1848,6 @@ bool QueryDbMainLoop(Config* config,
clang_complete->CodeComplete(msg->params, freshen_global); clang_complete->CodeComplete(msg->params, freshen_global);
} else if (non_global_code_complete_cache->IsCacheValid( } else if (non_global_code_complete_cache->IsCacheValid(
msg->params)) { msg->params)) {
LOG_S(INFO) << "[complete] Using cached completion results at "
<< msg->params.position.ToString();
non_global_code_complete_cache->WithLock([&]() { non_global_code_complete_cache->WithLock([&]() {
callback(non_global_code_complete_cache->cached_results_, callback(non_global_code_complete_cache->cached_results_,
true /*is_cached_result*/); true /*is_cached_result*/);
@ -1942,7 +1917,6 @@ bool QueryDbMainLoop(Config* config,
Timer timer; Timer timer;
ipc->SendOutMessageToClient(IpcId::TextDocumentSignatureHelp, ipc->SendOutMessageToClient(IpcId::TextDocumentSignatureHelp,
response); response);
timer.ResetAndPrint("[complete] Writing signature help results");
if (!is_cached_result) { if (!is_cached_result) {
signature_cache->WithLock([&]() { signature_cache->WithLock([&]() {
@ -1950,8 +1924,6 @@ bool QueryDbMainLoop(Config* config,
msg->params.textDocument.uri.GetPath(); msg->params.textDocument.uri.GetPath();
signature_cache->cached_completion_position_ = signature_cache->cached_completion_position_ =
msg->params.position; msg->params.position;
LOG_S(INFO) << "[complete] Updating "
"signature_cache->cached_results [3]";
signature_cache->cached_results_ = results; signature_cache->cached_results_ = results;
}); });
} }
@ -1962,8 +1934,6 @@ bool QueryDbMainLoop(Config* config,
std::placeholders::_2); std::placeholders::_2);
if (signature_cache->IsCacheValid(params)) { if (signature_cache->IsCacheValid(params)) {
LOG_S(INFO) << "[complete] Using cached completion results at "
<< params.position.ToString();
signature_cache->WithLock([&]() { signature_cache->WithLock([&]() {
callback(signature_cache->cached_results_, callback(signature_cache->cached_results_,
true /*is_cached_result*/); true /*is_cached_result*/);