Zengtudor/ccls
1
0
Fork 0
mirror of https://github.com/MaskRay/ccls.git synced 2025-04-03 23:42:09 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Change optional<...> Query{Func,Type}::Def to forward_list

Browse Source
This commit is contained in:
Fangrui Song 2018-02-17 23:09:05 -08:00
parent cfdb6bf422
commit 0f03146daa
11 changed files with 175 additions and 159 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/message_handler.cc
View File

@ -117,16 +117,16 @@ void EmitSemanticHighlighting(QueryDatabase* db,
// This switch statement also filters out symbols that are not highlighted. // This switch statement also filters out symbols that are not highlighted.
switch (sym.kind) { switch (sym.kind) {
case SymbolKind::Func: { case SymbolKind::Func: {
QueryFunc& func = db->GetFunc(sym); const QueryFunc::Def* def = db->GetFunc(sym).AnyDef();
if (!func.def) if (!def)
continue; // applies to for loop continue; // applies to for loop
// Don't highlight overloadable operators or implicit lambda -> // Don't highlight overloadable operators or implicit lambda ->
// std::function constructor. // std::function constructor.
std::string_view short_name = func.def->ShortName(); std::string_view short_name = def->ShortName();
if (short_name.compare(0, 8, "operator") == 0 || if (short_name.compare(0, 8, "operator") == 0 ||
short_name.compare(0, 27, "function<type-parameter-0-0") == 0) short_name.compare(0, 27, "function<type-parameter-0-0") == 0)
continue; // applies to for loop continue; // applies to for loop
kind = func.def->kind; kind = def->kind;
detailed_name = short_name; detailed_name = short_name;
// Check whether the function name is actually there. // Check whether the function name is actually there.

10
src/messages/cquery_base.cc
View File

@ -35,16 +35,14 @@ struct CqueryBaseHandler : BaseMessageHandler<Ipc_CqueryBase> {
}); });
for (SymbolRef sym : syms) { for (SymbolRef sym : syms) {
if (sym.kind == SymbolKind::Type) { if (sym.kind == SymbolKind::Type) {
QueryType& type = db->GetType(sym); if (const auto* def = db->GetType(sym).AnyDef())
if (type.def)
out.result = GetLsLocations(db, working_files, out.result = GetLsLocations(db, working_files,
ToUses(db, type.def->parents)); ToUses(db, def->parents));
break; break;
} else if (sym.kind == SymbolKind::Func) { } else if (sym.kind == SymbolKind::Func) {
QueryFunc& func = db->GetFunc(sym); if (const auto* def = db->GetFunc(sym).AnyDef())
if (func.def)
out.result = GetLsLocations(db, working_files, out.result = GetLsLocations(db, working_files,
ToUses(db, func.def->base)); ToUses(db, def->base));
break; break;
} }
} }

15
src/messages/cquery_call_tree.cc
View File

@ -53,15 +53,16 @@ std::vector<Out_CqueryCallTree::CallEntry> BuildInitialCallTree(
WorkingFiles* working_files, WorkingFiles* working_files,
QueryFuncId root) { QueryFuncId root) {
QueryFunc& root_func = db->funcs[root.id]; QueryFunc& root_func = db->funcs[root.id];
if (!root_func.def || !root_func.def->spell) const QueryFunc::Def* def = root_func.AnyDef();
if (!def || !def->spell)
return {}; return {};
optional<lsLocation> def_loc = optional<lsLocation> def_loc =
GetLsLocation(db, working_files, *root_func.def->spell); GetLsLocation(db, working_files, *def->spell);
if (!def_loc) if (!def_loc)
return {}; return {};
Out_CqueryCallTree::CallEntry entry; Out_CqueryCallTree::CallEntry entry;
entry.name = root_func.def->ShortName(); entry.name = def->ShortName();
entry.usr = std::to_string(root_func.usr); entry.usr = std::to_string(root_func.usr);
entry.location = *def_loc; entry.location = *def_loc;
entry.hasCallers = HasCallersOnSelfOrBaseOrDerived(db, root_func); entry.hasCallers = HasCallersOnSelfOrBaseOrDerived(db, root_func);
@ -75,7 +76,8 @@ std::vector<Out_CqueryCallTree::CallEntry> BuildExpandCallTree(
WorkingFiles* working_files, WorkingFiles* working_files,
QueryFuncId root) { QueryFuncId root) {
QueryFunc& root_func = db->funcs[root.id]; QueryFunc& root_func = db->funcs[root.id];
if (!root_func.def) const QueryFunc::Def* root_func_def = root_func.AnyDef();
if (!root_func_def)
return {}; return {};
std::vector<Out_CqueryCallTree::CallEntry> result; std::vector<Out_CqueryCallTree::CallEntry> result;
@ -107,11 +109,12 @@ std::vector<Out_CqueryCallTree::CallEntry> BuildExpandCallTree(
if (caller.kind == SymbolKind::Func) { if (caller.kind == SymbolKind::Func) {
QueryFunc& call_func = db->GetFunc(caller); QueryFunc& call_func = db->GetFunc(caller);
if (!call_func.def) const QueryFunc::Def* def = call_func.AnyDef();
if (!def)
return; return;
Out_CqueryCallTree::CallEntry call_entry; Out_CqueryCallTree::CallEntry call_entry;
call_entry.name = call_func.def->ShortName(); call_entry.name = def->ShortName();
call_entry.usr = std::to_string(call_func.usr); call_entry.usr = std::to_string(call_func.usr);
call_entry.location = *call_location; call_entry.location = *call_location;
call_entry.hasCallers = HasCallersOnSelfOrBaseOrDerived(db, call_func); call_entry.hasCallers = HasCallersOnSelfOrBaseOrDerived(db, call_func);

8
src/messages/cquery_member_hierarchy.cc
View File

@ -38,17 +38,17 @@ MAKE_REFLECT_STRUCT(Out_CqueryMemberHierarchy, jsonrpc, id, result);
std::vector<Out_CqueryMemberHierarchy::Entry> std::vector<Out_CqueryMemberHierarchy::Entry>
BuildInitial(QueryDatabase* db, WorkingFiles* working_files, QueryTypeId root) { BuildInitial(QueryDatabase* db, WorkingFiles* working_files, QueryTypeId root) {
QueryType& root_type = db->types[root.id]; const auto* root_type = db->types[root.id].AnyDef();
if (!root_type.def || !root_type.def->spell) if (!root_type || !root_type->spell)
return {}; return {};
optional<lsLocation> def_loc = optional<lsLocation> def_loc =
GetLsLocation(db, working_files, *root_type.def->spell); GetLsLocation(db, working_files, *root_type->spell);
if (!def_loc) if (!def_loc)
return {}; return {};
Out_CqueryMemberHierarchy::Entry entry; Out_CqueryMemberHierarchy::Entry entry;
entry.type_id = root; entry.type_id = root;
entry.name = root_type.def->ShortName(); entry.name = root_type->ShortName();
entry.location = *def_loc; entry.location = *def_loc;
return {entry}; return {entry};
} }

12
src/messages/cquery_random.cc
View File

@ -45,12 +45,12 @@ struct CqueryRandomHandler : BaseMessageHandler<Ipc_CqueryRandom> {
int n = 0; int n = 0;
for (RawId i = 0; i < db->funcs.size(); i++) for (RawId i = 0; i < db->funcs.size(); i++)
if (db->funcs[i].def) { if (db->funcs[i].AnyDef()) {
syms.push_back(SymbolIdx{Id<void>(i), SymbolKind::Func}); syms.push_back(SymbolIdx{Id<void>(i), SymbolKind::Func});
sym2id[syms.back()] = n++; sym2id[syms.back()] = n++;
} }
for (RawId i = 0; i < db->types.size(); i++) for (RawId i = 0; i < db->types.size(); i++)
if (db->types[i].def) { if (db->types[i].AnyDef()) {
syms.push_back(SymbolIdx{Id<void>(i), SymbolKind::Type}); syms.push_back(SymbolIdx{Id<void>(i), SymbolKind::Type});
sym2id[syms.back()] = n++; sym2id[syms.back()] = n++;
} }
@ -77,12 +77,12 @@ struct CqueryRandomHandler : BaseMessageHandler<Ipc_CqueryRandom> {
n++; n++;
} }
for (QueryType& type : db->types) for (QueryType& type : db->types)
if (type.AnyDef()) { if (const auto* def = type.AnyDef()) {
add(type.uses, 1); add(type.uses, 1);
Add(sym2id, adj, type.instances, n); Add(sym2id, adj, type.instances, n);
Add(sym2id, adj, type.def->funcs, n); Add(sym2id, adj, def->funcs, n);
Add(sym2id, adj, type.def->types, n); Add(sym2id, adj, def->types, n);
Add(sym2id, adj, type.def->vars, n); Add(sym2id, adj, def->vars, n);
n++; n++;
} }
for (QueryVar& var : db->vars) for (QueryVar& var : db->vars)

48
src/messages/cquery_type_hierarchy_tree.cc
View File

@ -32,14 +32,15 @@ BuildParentInheritanceHierarchyForType(QueryDatabase* db,
WorkingFiles* working_files, WorkingFiles* working_files,
QueryType& root_type) { QueryType& root_type) {
std::vector<Out_CqueryTypeHierarchyTree::TypeEntry> parent_entries; std::vector<Out_CqueryTypeHierarchyTree::TypeEntry> parent_entries;
parent_entries.reserve(root_type.def->parents.size()); const QueryType::Def* def = root_type.AnyDef();
parent_entries.reserve(def->parents.size());
EachWithGen(db->types, root_type.def->parents, [&](QueryType& parent_type) { EachWithGen(db->types, def->parents, [&](QueryType& parent_type) {
Out_CqueryTypeHierarchyTree::TypeEntry parent_entry; Out_CqueryTypeHierarchyTree::TypeEntry parent_entry;
parent_entry.name = parent_type.def->detailed_name.c_str(); const QueryType::Def* def1 = parent_type.AnyDef();
if (parent_type.def->spell) parent_entry.name = def1->detailed_name.c_str();
parent_entry.location = GetLsLocation( if (def1->spell)
db, working_files, *parent_type.def->spell); parent_entry.location = GetLsLocation(db, working_files, *def1->spell);
parent_entry.children = parent_entry.children =
BuildParentInheritanceHierarchyForType(db, working_files, parent_type); BuildParentInheritanceHierarchyForType(db, working_files, parent_type);
@ -54,12 +55,12 @@ BuildInheritanceHierarchyForType(QueryDatabase* db,
WorkingFiles* working_files, WorkingFiles* working_files,
QueryType& root_type) { QueryType& root_type) {
Out_CqueryTypeHierarchyTree::TypeEntry entry; Out_CqueryTypeHierarchyTree::TypeEntry entry;
const QueryType::Def* def = root_type.AnyDef();
// Name and location. // Name and location.
entry.name = root_type.def->detailed_name; entry.name = def->detailed_name;
if (root_type.def->spell) if (def->spell)
entry.location = entry.location = GetLsLocation(db, working_files, *def->spell);
GetLsLocation(db, working_files, *root_type.def->spell);
entry.children.reserve(root_type.derived.size()); entry.children.reserve(root_type.derived.size());
@ -90,20 +91,20 @@ BuildParentInheritanceHierarchyForFunc(QueryDatabase* db,
std::vector<Out_CqueryTypeHierarchyTree::TypeEntry> entries; std::vector<Out_CqueryTypeHierarchyTree::TypeEntry> entries;
QueryFunc& root_func = db->funcs[root.id]; QueryFunc& root_func = db->funcs[root.id];
if (!root_func.def || root_func.def->base.empty()) const QueryFunc::Def* def = root_func.AnyDef();
if (!def || def->base.empty())
return {}; return {};
// FIXME WithGen for (auto parent_id : def->base) {
for (auto parent_id : root_func.def->base) {
QueryFunc& parent_func = db->funcs[parent_id.id]; QueryFunc& parent_func = db->funcs[parent_id.id];
if (!parent_func.def) const QueryFunc::Def* def1 = parent_func.AnyDef();
if (!def1)
continue; continue;
Out_CqueryTypeHierarchyTree::TypeEntry parent_entry; Out_CqueryTypeHierarchyTree::TypeEntry parent_entry;
parent_entry.name = parent_func.def->detailed_name; parent_entry.name = def1->detailed_name;
if (parent_func.def->spell) if (def1->spell)
parent_entry.location = GetLsLocation( parent_entry.location = GetLsLocation(db, working_files, *def1->spell);
db, working_files, *parent_func.def->spell);
parent_entry.children = parent_entry.children =
BuildParentInheritanceHierarchyForFunc(db, working_files, parent_id); BuildParentInheritanceHierarchyForFunc(db, working_files, parent_id);
@ -118,16 +119,17 @@ BuildInheritanceHierarchyForFunc(QueryDatabase* db,
WorkingFiles* working_files, WorkingFiles* working_files,
QueryFuncId root_id) { QueryFuncId root_id) {
QueryFunc& root_func = db->funcs[root_id.id]; QueryFunc& root_func = db->funcs[root_id.id];
if (!root_func.def) const QueryFunc::Def* def = root_func.AnyDef();
if (!def)
return nullopt; return nullopt;
Out_CqueryTypeHierarchyTree::TypeEntry entry; Out_CqueryTypeHierarchyTree::TypeEntry entry;
// Name and location. // Name and location.
entry.name = root_func.def->detailed_name; entry.name = def->detailed_name;
if (root_func.def->spell) if (def->spell)
entry.location = entry.location =
GetLsLocation(db, working_files, *root_func.def->spell); GetLsLocation(db, working_files, *def->spell);
entry.children.reserve(root_func.derived.size()); entry.children.reserve(root_func.derived.size());
@ -169,7 +171,7 @@ struct CqueryTypeHierarchyTreeHandler
FindSymbolsAtLocation(working_file, file, request->params.position)) { FindSymbolsAtLocation(working_file, file, request->params.position)) {
if (sym.kind == SymbolKind::Type) { if (sym.kind == SymbolKind::Type) {
QueryType& type = db->GetType(sym); QueryType& type = db->GetType(sym);
if (type.def) if (type.AnyDef())
out.result = out.result =
BuildInheritanceHierarchyForType(db, working_files, type); BuildInheritanceHierarchyForType(db, working_files, type);
break; break;

50
src/messages/text_document_code_action.cc
View File

@ -69,13 +69,14 @@ optional<QueryFileId> GetImplementationFile(QueryDatabase* db,
for (SymbolRef sym : file->def->outline) { for (SymbolRef sym : file->def->outline) {
switch (sym.kind) { switch (sym.kind) {
case SymbolKind::Func: { case SymbolKind::Func: {
QueryFunc& func = db->GetFunc(sym); if (const auto* def = db->GetFunc(sym).AnyDef()) {
// Note: we ignore the definition if it is in the same file (ie, // Note: we ignore the definition if it is in the same file (ie,
// possibly a header). // possibly a header).
if (func.def && func.def->extent) { if (def->extent) {
QueryFileId t = func.def->extent->file; QueryFileId t = def->extent->file;
if (t != file_id) if (t != file_id)
return t; return t;
}
} }
break; break;
} }
@ -149,7 +150,8 @@ optional<lsTextEdit> BuildAutoImplementForFunction(QueryDatabase* db,
QueryFileId decl_file_id, QueryFileId decl_file_id,
QueryFileId impl_file_id, QueryFileId impl_file_id,
QueryFunc& func) { QueryFunc& func) {
assert(func.def); const QueryFunc::Def* def = func.AnyDef();
assert(def);
for (Use decl : func.declarations) { for (Use decl : func.declarations) {
if (decl.file != decl_file_id) if (decl.file != decl_file_id)
continue; continue;
@ -160,12 +162,12 @@ optional<lsTextEdit> BuildAutoImplementForFunction(QueryDatabase* db,
optional<std::string> type_name; optional<std::string> type_name;
optional<lsPosition> same_file_insert_end; optional<lsPosition> same_file_insert_end;
if (func.def->declaring_type) { if (def->declaring_type) {
QueryType& declaring_type = db->types[func.def->declaring_type->id]; QueryType& declaring_type = db->types[def->declaring_type->id];
if (declaring_type.def) { if (const auto* def1 = declaring_type.AnyDef()) {
type_name = std::string(declaring_type.def->ShortName()); type_name = std::string(def1->ShortName());
optional<lsRange> ls_type_extent = GetLsRange( optional<lsRange> ls_type_extent =
working_file, declaring_type.def->extent->range); GetLsRange(working_file, def1->extent->range);
if (ls_type_extent) { if (ls_type_extent) {
same_file_insert_end = ls_type_extent->end; same_file_insert_end = ls_type_extent->end;
same_file_insert_end->character += 1; // move past semicolon. same_file_insert_end->character += 1; // move past semicolon.
@ -201,7 +203,8 @@ optional<lsTextEdit> BuildAutoImplementForFunction(QueryDatabase* db,
switch (sym.kind) { switch (sym.kind) {
case SymbolKind::Func: { case SymbolKind::Func: {
QueryFunc& sym_func = db->GetFunc(sym); QueryFunc& sym_func = db->GetFunc(sym);
if (!sym_func.def || !sym_func.def->extent) const QueryFunc::Def* def1 = sym_func.AnyDef();
if (!def1 || !def1->extent)
break; break;
for (Use func_decl : sym_func.declarations) { for (Use func_decl : sym_func.declarations) {
@ -209,7 +212,7 @@ optional<lsTextEdit> BuildAutoImplementForFunction(QueryDatabase* db,
int dist = func_decl.range.start.line - decl.range.start.line; int dist = func_decl.range.start.line - decl.range.start.line;
if (abs(dist) < abs(best_dist)) { if (abs(dist) < abs(best_dist)) {
optional<lsLocation> def_loc = GetLsLocation( optional<lsLocation> def_loc = GetLsLocation(
db, working_files, *sym_func.def->extent); db, working_files, *def1->extent);
if (!def_loc) if (!def_loc)
continue; continue;
@ -347,7 +350,8 @@ struct TextDocumentCodeActionHandler
switch (sym.kind) { switch (sym.kind) {
case SymbolKind::Type: { case SymbolKind::Type: {
QueryType& type = db->GetType(sym); QueryType& type = db->GetType(sym);
if (!type.def) const QueryType::Def* def = type.AnyDef();
if (!def)
break; break;
int num_edits = 0; int num_edits = 0;
@ -355,8 +359,9 @@ struct TextDocumentCodeActionHandler
// Get implementation file. // Get implementation file.
Out_TextDocumentCodeAction::Command command; Out_TextDocumentCodeAction::Command command;
EachWithGen(db->funcs, type.def->funcs, [&](QueryFunc& func_def) { EachWithGen(db->funcs, def->funcs, [&](QueryFunc& func_def) {
if (func_def.def->extent) const QueryFunc::Def* def1 = func_def.AnyDef();
if (def1->extent)
return; return;
EnsureImplFile(db, file_id, impl_uri /*out*/, impl_file_id /*out*/); EnsureImplFile(db, file_id, impl_uri /*out*/, impl_file_id /*out*/);
optional<lsTextEdit> edit = BuildAutoImplementForFunction( optional<lsTextEdit> edit = BuildAutoImplementForFunction(
@ -390,7 +395,7 @@ struct TextDocumentCodeActionHandler
command.arguments.textDocumentUri = *impl_uri; command.arguments.textDocumentUri = *impl_uri;
command.title = "Auto-Implement " + std::to_string(num_edits) + command.title = "Auto-Implement " + std::to_string(num_edits) +
" methods on " + std::string(type.def->ShortName()); " methods on " + std::string(def->ShortName());
command.command = "cquery._autoImplement"; command.command = "cquery._autoImplement";
out.result.push_back(command); out.result.push_back(command);
break; break;
@ -398,14 +403,15 @@ struct TextDocumentCodeActionHandler
case SymbolKind::Func: { case SymbolKind::Func: {
QueryFunc& func = db->GetFunc(sym); QueryFunc& func = db->GetFunc(sym);
if (!func.def || func.def->extent) const QueryFunc::Def* def = func.AnyDef();
if (!def || def->extent)
break; break;
EnsureImplFile(db, file_id, impl_uri /*out*/, impl_file_id /*out*/); EnsureImplFile(db, file_id, impl_uri /*out*/, impl_file_id /*out*/);
// Get implementation file. // Get implementation file.
Out_TextDocumentCodeAction::Command command; Out_TextDocumentCodeAction::Command command;
command.title = "Auto-Implement " + std::string(func.def->ShortName()); command.title = "Auto-Implement " + std::string(def->ShortName());
command.command = "cquery._autoImplement"; command.command = "cquery._autoImplement";
command.arguments.textDocumentUri = *impl_uri; command.arguments.textDocumentUri = *impl_uri;
optional<lsTextEdit> edit = BuildAutoImplementForFunction( optional<lsTextEdit> edit = BuildAutoImplementForFunction(

14
src/messages/text_document_code_lens.cc
View File

@ -155,9 +155,8 @@ struct TextDocumentCodeLensHandler
switch (sym.kind) { switch (sym.kind) {
case SymbolKind::Type: { case SymbolKind::Type: {
QueryType& type = db->GetType(sym); QueryType& type = db->GetType(sym);
if (!type.def) const QueryType::Def* def = type.AnyDef();
continue; if (!def || def->kind == ClangSymbolKind::Namespace)
if (type.def->kind == ClangSymbolKind::Namespace)
continue; continue;
AddCodeLens("ref", "refs", &common, OffsetStartColumn(sym, 0), AddCodeLens("ref", "refs", &common, OffsetStartColumn(sym, 0),
type.uses, true /*force_display*/); type.uses, true /*force_display*/);
@ -169,7 +168,8 @@ struct TextDocumentCodeLensHandler
} }
case SymbolKind::Func: { case SymbolKind::Func: {
QueryFunc& func = db->GetFunc(sym); QueryFunc& func = db->GetFunc(sym);
if (!func.def) const QueryFunc::Def* def = func.AnyDef();
if (!def)
continue; continue;
int16_t offset = 0; int16_t offset = 0;
@ -215,9 +215,9 @@ struct TextDocumentCodeLensHandler
ToUses(db, func.derived), false /*force_display*/); ToUses(db, func.derived), false /*force_display*/);
// "Base" // "Base"
if (func.def->base.size() == 1) { if (def->base.size() == 1) {
Maybe<Use> base_loc = GetDefinitionSpellingOfSymbol( Maybe<Use> base_loc = GetDefinitionSpellingOfSymbol(
db, SymbolIdx{func.def->base[0], SymbolKind::Func}); db, SymbolIdx{def->base[0], SymbolKind::Func});
if (base_loc) { if (base_loc) {
optional<lsLocation> ls_base = optional<lsLocation> ls_base =
GetLsLocation(db, working_files, *base_loc); GetLsLocation(db, working_files, *base_loc);
@ -239,7 +239,7 @@ struct TextDocumentCodeLensHandler
} }
} else { } else {
AddCodeLens("base", "base", &common, OffsetStartColumn(sym, 1), AddCodeLens("base", "base", &common, OffsetStartColumn(sym, 1),
ToUses(db, func.def->base), ToUses(db, def->base),
false /*force_display*/); false /*force_display*/);
} }

16
src/query.cc
View File

@ -752,8 +752,7 @@ void QueryDatabase::RemoveUsrs(SymbolKind usr_kind,
QueryType& type = types[usr_to_type[usr].id]; QueryType& type = types[usr_to_type[usr].id];
if (type.symbol_idx) if (type.symbol_idx)
symbols[type.symbol_idx->id].kind = SymbolKind::Invalid; symbols[type.symbol_idx->id].kind = SymbolKind::Invalid;
//type.def = QueryType::Def(); type.def.clear();
type.def = nullopt;
} }
break; break;
} }
@ -762,8 +761,7 @@ void QueryDatabase::RemoveUsrs(SymbolKind usr_kind,
QueryFunc& func = funcs[usr_to_func[usr].id]; QueryFunc& func = funcs[usr_to_func[usr].id];
if (func.symbol_idx) if (func.symbol_idx)
symbols[func.symbol_idx->id].kind = SymbolKind::Invalid; symbols[func.symbol_idx->id].kind = SymbolKind::Invalid;
//func.def = QueryFunc::Def(); func.def.clear();
func.def = nullopt;
} }
break; break;
} }
@ -851,9 +849,9 @@ void QueryDatabase::ImportOrUpdate(
QueryType& existing = types[it->second.id]; QueryType& existing = types[it->second.id];
// Keep the existing definition if it is higher quality. // Keep the existing definition if it is higher quality.
if (!(existing.def && existing.def->spell && if (!(existing.AnyDef() && existing.AnyDef()->spell &&
!def.value.spell)) { !def.value.spell)) {
existing.def = std::move(def.value); existing.def.push_front(std::move(def.value));
UpdateSymbols(&existing.symbol_idx, SymbolKind::Type, it->second); UpdateSymbols(&existing.symbol_idx, SymbolKind::Type, it->second);
} }
} }
@ -873,9 +871,9 @@ void QueryDatabase::ImportOrUpdate(
QueryFunc& existing = funcs[it->second.id]; QueryFunc& existing = funcs[it->second.id];
// Keep the existing definition if it is higher quality. // Keep the existing definition if it is higher quality.
if (!(existing.def && existing.def->spell && if (!(existing.AnyDef() && existing.AnyDef()->spell &&
!def.value.spell)) { !def.value.spell)) {
existing.def = std::move(def.value); existing.def.push_front(std::move(def.value));
UpdateSymbols(&existing.symbol_idx, SymbolKind::Func, it->second); UpdateSymbols(&existing.symbol_idx, SymbolKind::Func, it->second);
} }
} }

24
src/query.h
View File

@ -140,14 +140,20 @@ struct QueryType {
Usr usr; Usr usr;
Maybe<Id<void>> symbol_idx; Maybe<Id<void>> symbol_idx;
optional<Def> def; std::forward_list<Def> def;
std::vector<QueryTypeId> derived; std::vector<QueryTypeId> derived;
std::vector<QueryVarId> instances; std::vector<QueryVarId> instances;
std::vector<Use> uses; std::vector<Use> uses;
explicit QueryType(const Usr& usr) : usr(usr) {} explicit QueryType(const Usr& usr) : usr(usr) {}
const Def* AnyDef() const { return def ? &*def : nullptr; } const Def* AnyDef() const {
Def* AnyDef() { return def ? &*def : nullptr; } if (def.empty()) return nullptr;
return &def.front();
}
Def* AnyDef() {
if (def.empty()) return nullptr;
return &def.front();
}
}; };
struct QueryFunc { struct QueryFunc {
@ -159,14 +165,20 @@ struct QueryFunc {
Usr usr; Usr usr;
Maybe<Id<void>> symbol_idx; Maybe<Id<void>> symbol_idx;
optional<Def> def; std::forward_list<Def> def;
std::vector<Use> declarations; std::vector<Use> declarations;
std::vector<QueryFuncId> derived; std::vector<QueryFuncId> derived;
std::vector<Use> uses; std::vector<Use> uses;
explicit QueryFunc(const Usr& usr) : usr(usr) {} explicit QueryFunc(const Usr& usr) : usr(usr) {}
const Def* AnyDef() const { return def ? &*def : nullptr; } const Def* AnyDef() const {
Def* AnyDef() { return def ? &*def : nullptr; } if (def.empty()) return nullptr;
return &def.front();
}
Def* AnyDef() {
if (def.empty()) return nullptr;
return &def.front();
}
}; };
struct QueryVar { struct QueryVar {

129
src/query_utils.cc
View File

@ -21,16 +21,16 @@ int ComputeRangeSize(const Range& range) {
Maybe<Use> GetDefinitionSpellingOfSymbol(QueryDatabase* db, Maybe<Use> GetDefinitionSpellingOfSymbol(QueryDatabase* db,
SymbolIdx sym) { SymbolIdx sym) {
switch (sym.kind) { switch (sym.kind) {
case SymbolKind::Type: { case SymbolKind::File:
QueryType& type = db->GetType(sym); break;
if (type.def) case SymbolKind::Func: {
return type.def->spell; if (const auto* def = db->GetFunc(sym).AnyDef())
return def->spell;
break; break;
} }
case SymbolKind::Func: { case SymbolKind::Type: {
QueryFunc& func = db->GetFunc(sym); if (const auto* def = db->GetType(sym).AnyDef())
if (func.def) return def->spell;
return func.def->spell;
break; break;
} }
case SymbolKind::Var: { case SymbolKind::Var: {
@ -39,8 +39,6 @@ Maybe<Use> GetDefinitionSpellingOfSymbol(QueryDatabase* db,
return def->spell; return def->spell;
break; break;
} }
case SymbolKind::File:
break;
case SymbolKind::Invalid: case SymbolKind::Invalid:
assert(false && "unexpected"); assert(false && "unexpected");
break; break;
@ -50,16 +48,17 @@ Maybe<Use> GetDefinitionSpellingOfSymbol(QueryDatabase* db,
Maybe<Use> GetDefinitionExtentOfSymbol(QueryDatabase* db, SymbolIdx sym) { Maybe<Use> GetDefinitionExtentOfSymbol(QueryDatabase* db, SymbolIdx sym) {
switch (sym.kind) { switch (sym.kind) {
case SymbolKind::Type: { case SymbolKind::File:
QueryType& type = db->GetType(sym); return Use(Range(Position(0, 0), Position(0, 0)), sym.id, sym.kind,
if (type.def) Role::None, QueryFileId(sym.id));
return type.def->extent; case SymbolKind::Func: {
if (const auto* def = db->GetFunc(sym).AnyDef())
return def->extent;
break; break;
} }
case SymbolKind::Func: { case SymbolKind::Type: {
QueryFunc& func = db->GetFunc(sym); if (const auto* def = db->GetType(sym).AnyDef())
if (func.def) return def->extent;
return func.def->extent;
break; break;
} }
case SymbolKind::Var: { case SymbolKind::Var: {
@ -68,9 +67,6 @@ Maybe<Use> GetDefinitionExtentOfSymbol(QueryDatabase* db, SymbolIdx sym) {
return def->extent; return def->extent;
break; break;
} }
case SymbolKind::File:
return Use(Range(Position(0, 0), Position(0, 0)), sym.id, sym.kind,
Role::None, QueryFileId(sym.id));
case SymbolKind::Invalid: { case SymbolKind::Invalid: {
assert(false && "unexpected"); assert(false && "unexpected");
break; break;
@ -82,28 +78,26 @@ Maybe<Use> GetDefinitionExtentOfSymbol(QueryDatabase* db, SymbolIdx sym) {
Maybe<QueryFileId> GetDeclarationFileForSymbol(QueryDatabase* db, Maybe<QueryFileId> GetDeclarationFileForSymbol(QueryDatabase* db,
SymbolIdx sym) { SymbolIdx sym) {
switch (sym.kind) { switch (sym.kind) {
case SymbolKind::Type: { case SymbolKind::File:
QueryType& type = db->GetType(sym); return QueryFileId(sym.id);
if (type.def)
return type.def->file;
break;
}
case SymbolKind::Func: { case SymbolKind::Func: {
QueryFunc& func = db->GetFunc(sym); QueryFunc& func = db->GetFunc(sym);
if (!func.declarations.empty()) if (!func.declarations.empty())
return func.declarations[0].file; return func.declarations[0].file;
if (func.def) if (const auto* def = func.AnyDef())
return func.def->file; return def->file;
break; break;
} }
case SymbolKind::Var: { case SymbolKind::Type: {
const QueryVar::Def* def = db->GetVar(sym).AnyDef(); if (const auto* def = db->GetType(sym).AnyDef())
if (def) return def->file;
break;
}
case SymbolKind::Var: {
if (const auto* def = db->GetVar(sym).AnyDef())
return def->file; return def->file;
break; break;
} }
case SymbolKind::File:
return QueryFileId(sym.id);
case SymbolKind::Invalid: { case SymbolKind::Invalid: {
assert(false && "unexpected"); assert(false && "unexpected");
break; break;
@ -118,8 +112,9 @@ std::vector<Use> ToUses(QueryDatabase* db,
ret.reserve(ids.size()); ret.reserve(ids.size());
for (auto id : ids) { for (auto id : ids) {
QueryFunc& func = db->funcs[id.id]; QueryFunc& func = db->funcs[id.id];
if (func.def && func.def->spell) const QueryFunc::Def* def = func.AnyDef();
ret.push_back(*func.def->spell); if (def && def->spell)
ret.push_back(*def->spell);
else if (func.declarations.size()) else if (func.declarations.size())
ret.push_back(func.declarations[0]); ret.push_back(func.declarations[0]);
} }
@ -132,8 +127,9 @@ std::vector<Use> ToUses(QueryDatabase* db,
ret.reserve(ids.size()); ret.reserve(ids.size());
for (auto id : ids) { for (auto id : ids) {
QueryType& type = db->types[id.id]; QueryType& type = db->types[id.id];
if (type.def && type.def->spell) const QueryType::Def* def = type.AnyDef();
ret.push_back(*type.def->spell); if (def && def->spell)
ret.push_back(*def->spell);
} }
return ret; return ret;
} }
@ -143,7 +139,7 @@ std::vector<Use> ToUses(QueryDatabase* db, const std::vector<QueryVarId>& ids) {
ret.reserve(ids.size()); ret.reserve(ids.size());
for (auto id : ids) { for (auto id : ids) {
QueryVar& var = db->vars[id.id]; QueryVar& var = db->vars[id.id];
QueryVar::Def* def = var.AnyDef(); const QueryVar::Def* def = var.AnyDef();
if (def && def->spell) if (def && def->spell)
ret.push_back(*def->spell); ret.push_back(*def->spell);
else if (var.declarations.size()) else if (var.declarations.size())
@ -205,11 +201,10 @@ std::vector<Use> GetDeclarationsOfSymbolForGotoDefinition(
// function has the postfix `ForGotoDefintion`, but it lets the user // function has the postfix `ForGotoDefintion`, but it lets the user
// jump to the start of a type if clicking goto-definition on the same // jump to the start of a type if clicking goto-definition on the same
// type from within the type definition. // type from within the type definition.
QueryType& type = db->GetType(sym); if (const auto* def = db->GetType(sym).AnyDef()) {
if (type.def) { Maybe<Use> spell = def->spell;
Maybe<Use> def = type.def->spell; if (spell)
if (def) return {*spell};
return {*def};
} }
break; break;
} }
@ -228,10 +223,11 @@ bool HasCallersOnSelfOrBaseOrDerived(QueryDatabase* db, QueryFunc& root) {
// Check self. // Check self.
if (!root.uses.empty()) if (!root.uses.empty())
return true; return true;
const QueryFunc::Def* def = root.AnyDef();
// Check for base calls. // Check for base calls.
std::queue<QueryFunc*> queue; std::queue<QueryFunc*> queue;
EachWithGen<QueryFunc>(db->funcs, root.def->base, [&](QueryFunc& func) { EachWithGen<QueryFunc>(db->funcs, def->base, [&](QueryFunc& func) {
queue.push(&func); queue.push(&func);
}); });
while (!queue.empty()) { while (!queue.empty()) {
@ -239,8 +235,8 @@ bool HasCallersOnSelfOrBaseOrDerived(QueryDatabase* db, QueryFunc& root) {
queue.pop(); queue.pop();
if (!func.uses.empty()) if (!func.uses.empty())
return true; return true;
if (func.def) if (def)
EachWithGen<QueryFunc>(db->funcs, func.def->base, [&](QueryFunc& func1) { EachWithGen<QueryFunc>(db->funcs, def->base, [&](QueryFunc& func1) {
queue.push(&func1); queue.push(&func1);
}); });
} }
@ -265,11 +261,12 @@ bool HasCallersOnSelfOrBaseOrDerived(QueryDatabase* db, QueryFunc& root) {
std::vector<Use> GetCallersForAllBaseFunctions(QueryDatabase* db, std::vector<Use> GetCallersForAllBaseFunctions(QueryDatabase* db,
QueryFunc& root) { QueryFunc& root) {
std::vector<Use> callers; std::vector<Use> callers;
if (!root.def) const QueryFunc::Def* def = root.AnyDef();
if (!def)
return callers; return callers;
std::queue<QueryFunc*> queue; std::queue<QueryFunc*> queue;
EachWithGen<QueryFunc>(db->funcs, root.def->base, [&](QueryFunc& func1) { EachWithGen<QueryFunc>(db->funcs, def->base, [&](QueryFunc& func1) {
queue.push(&func1); queue.push(&func1);
}); });
while (!queue.empty()) { while (!queue.empty()) {
@ -277,8 +274,8 @@ std::vector<Use> GetCallersForAllBaseFunctions(QueryDatabase* db,
queue.pop(); queue.pop();
AddRange(&callers, func.uses); AddRange(&callers, func.uses);
if (func.def) if (def)
EachWithGen<QueryFunc>(db->funcs, func.def->base, [&](QueryFunc& func1) { EachWithGen<QueryFunc>(db->funcs, def->base, [&](QueryFunc& func1) {
queue.push(&func1); queue.push(&func1);
}); });
} }
@ -453,19 +450,19 @@ optional<lsSymbolInformation> GetSymbolInfo(QueryDatabase* db,
return info; return info;
} }
case SymbolKind::Type: { case SymbolKind::Type: {
QueryType& type = db->GetType(sym); const QueryType::Def* def = db->GetType(sym).AnyDef();
if (!type.def) if (!def)
break; break;
lsSymbolInformation info; lsSymbolInformation info;
if (use_short_name) if (use_short_name)
info.name = type.def->ShortName(); info.name = def->ShortName();
else else
info.name = type.def->detailed_name; info.name = def->detailed_name;
if (type.def->detailed_name.c_str() != type.def->ShortName()) if (def->detailed_name.c_str() != def->ShortName())
info.containerName = type.def->detailed_name; info.containerName = def->detailed_name;
// TODO ClangSymbolKind -> lsSymbolKind // TODO ClangSymbolKind -> lsSymbolKind
switch (type.def->kind) { switch (def->kind) {
default: default:
info.kind = lsSymbolKind::Class; info.kind = lsSymbolKind::Class;
break; break;
@ -476,17 +473,17 @@ optional<lsSymbolInformation> GetSymbolInfo(QueryDatabase* db,
return info; return info;
} }
case SymbolKind::Func: { case SymbolKind::Func: {
QueryFunc& func = db->GetFunc(sym); const QueryFunc::Def* def = db->GetFunc(sym).AnyDef();
if (!func.def) if (!def)
break; break;
lsSymbolInformation info; lsSymbolInformation info;
if (use_short_name) if (use_short_name)
info.name = func.def->ShortName(); info.name = def->ShortName();
else else
info.name = func.def->detailed_name; info.name = def->detailed_name;
info.containerName = func.def->detailed_name; info.containerName = def->detailed_name;
switch (func.def->kind) { switch (def->kind) {
default: default:
info.kind = lsSymbolKind::Function; info.kind = lsSymbolKind::Function;
break; break;