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

$ccls/publishSemanticHighlighting: use pair<int,int> in place of lsRange

Browse Source
This commit is contained in:
Fangrui Song 2018-07-08 19:56:33 -07:00
parent 0a304096df
commit 7d1d4b410b
3 changed files with 153 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/indexer.cc
View File

@ -534,11 +534,13 @@ public:
off |= 1u << 31;
Loc = SourceLocation::getFromRawEncoding(off);
}
#else
FileID LocFID;
#endif
SourceLocation Spell = SM.getSpellingLoc(Loc);
Loc = SM.getFileLoc(Loc);
Range loc = FromTokenRange(SM, Lang, SourceRange(Loc, Loc));
FileID LocFID = SM.getFileID(Loc);
LocFID = SM.getFileID(Loc);
const FileEntry *FE = SM.getFileEntryForID(LocFID);
if (!FE) {
// TODO

264
src/message_handler.cc
View File

@ -1,9 +1,9 @@
#include "message_handler.h"
#include "log.hh"
#include "pipeline.hh"
#include "project.h"
#include "query_utils.h"
#include "pipeline.hh"
using namespace ccls;
using namespace clang;
@ -28,10 +28,10 @@ MAKE_REFLECT_STRUCT(Out_CclsSetSkippedRanges, jsonrpc, method, params);
struct ScanLineEvent {
lsPosition pos;
lsPosition end_pos; // Second key when there is a tie for insertion events.
lsPosition end_pos; // Second key when there is a tie for insertion events.
int id;
Out_CclsPublishSemanticHighlighting::Symbol* symbol;
bool operator<(const ScanLineEvent& other) const {
Out_CclsPublishSemanticHighlighting::Symbol *symbol;
bool operator<(const ScanLineEvent &other) const {
// See the comments below when insertion/deletion events are inserted.
if (!(pos == other.pos))
return pos < other.pos;
@ -42,17 +42,15 @@ struct ScanLineEvent {
return symbol->kind < other.symbol->kind;
}
};
} // namespace
} // namespace
SemanticHighlightSymbolCache::Entry::Entry(
SemanticHighlightSymbolCache* all_caches,
const std::string& path)
SemanticHighlightSymbolCache *all_caches, const std::string &path)
: all_caches_(all_caches), path(path) {}
std::optional<int> SemanticHighlightSymbolCache::Entry::TryGetStableId(
SymbolKind kind,
const std::string& detailed_name) {
TNameToId* map = GetMapForSymbol_(kind);
SymbolKind kind, const std::string &detailed_name) {
TNameToId *map = GetMapForSymbol_(kind);
auto it = map->find(detailed_name);
if (it != map->end())
return it->second;
@ -61,14 +59,13 @@ std::optional<int> SemanticHighlightSymbolCache::Entry::TryGetStableId(
}
int SemanticHighlightSymbolCache::Entry::GetStableId(
SymbolKind kind,
const std::string& detailed_name) {
SymbolKind kind, const std::string &detailed_name) {
std::optional<int> id = TryGetStableId(kind, detailed_name);
if (id)
return *id;
// Create a new id. First try to find a key in another map.
all_caches_->cache_.IterateValues([&](const std::shared_ptr<Entry>& entry) {
all_caches_->cache_.IterateValues([&](const std::shared_ptr<Entry> &entry) {
std::optional<int> other_id = entry->TryGetStableId(kind, detailed_name);
if (other_id) {
id = other_id;
@ -78,24 +75,24 @@ int SemanticHighlightSymbolCache::Entry::GetStableId(
});
// Create a new id.
TNameToId* map = GetMapForSymbol_(kind);
TNameToId *map = GetMapForSymbol_(kind);
if (!id)
id = all_caches_->next_stable_id_++;
return (*map)[detailed_name] = *id;
}
SemanticHighlightSymbolCache::Entry::TNameToId*
SemanticHighlightSymbolCache::Entry::TNameToId *
SemanticHighlightSymbolCache::Entry::GetMapForSymbol_(SymbolKind kind) {
switch (kind) {
case SymbolKind::Type:
return &detailed_type_name_to_stable_id;
case SymbolKind::Func:
return &detailed_func_name_to_stable_id;
case SymbolKind::Var:
return &detailed_var_name_to_stable_id;
case SymbolKind::File:
case SymbolKind::Invalid:
break;
case SymbolKind::Type:
return &detailed_type_name_to_stable_id;
case SymbolKind::Func:
return &detailed_func_name_to_stable_id;
case SymbolKind::Var:
return &detailed_var_name_to_stable_id;
case SymbolKind::File:
case SymbolKind::Invalid:
break;
}
assert(false);
return nullptr;
@ -110,7 +107,7 @@ void SemanticHighlightSymbolCache::Init() {
}
std::shared_ptr<SemanticHighlightSymbolCache::Entry>
SemanticHighlightSymbolCache::GetCacheForFile(const std::string& path) {
SemanticHighlightSymbolCache::GetCacheForFile(const std::string &path) {
return cache_.Get(
path, [&, this]() { return std::make_shared<Entry>(this, path); });
}
@ -119,24 +116,21 @@ MessageHandler::MessageHandler() {
// Dynamically allocate |message_handlers|, otherwise there will be static
// initialization order races.
if (!message_handlers)
message_handlers = new std::vector<MessageHandler*>();
message_handlers = new std::vector<MessageHandler *>();
message_handlers->push_back(this);
}
// static
std::vector<MessageHandler*>* MessageHandler::message_handlers = nullptr;
std::vector<MessageHandler *> *MessageHandler::message_handlers = nullptr;
bool FindFileOrFail(DB* db,
Project* project,
std::optional<lsRequestId> id,
const std::string& absolute_path,
QueryFile** out_query_file,
int* out_file_id) {
bool FindFileOrFail(DB *db, Project *project, std::optional<lsRequestId> id,
const std::string &absolute_path,
QueryFile **out_query_file, int *out_file_id) {
*out_query_file = nullptr;
auto it = db->name2file_id.find(LowerPathIfInsensitive(absolute_path));
if (it != db->name2file_id.end()) {
QueryFile& file = db->files[it->second];
QueryFile &file = db->files[it->second];
if (file.def) {
*out_query_file = &file;
if (out_file_id)
@ -152,7 +146,7 @@ bool FindFileOrFail(DB* db,
{
std::lock_guard<std::mutex> lock(project->mutex_);
indexing = project->absolute_path_to_entry_index_.find(absolute_path) !=
project->absolute_path_to_entry_index_.end();
project->absolute_path_to_entry_index_.end();
}
if (indexing)
LOG_S(INFO) << "\"" << absolute_path << "\" is being indexed.";
@ -187,10 +181,9 @@ void EmitSkippedRanges(WorkingFile *working_file,
pipeline::WriteStdout(kMethodType_CclsPublishSkippedRanges, out);
}
void EmitSemanticHighlighting(DB* db,
SemanticHighlightSymbolCache* semantic_cache,
WorkingFile* wfile,
QueryFile* file) {
void EmitSemanticHighlighting(DB *db,
SemanticHighlightSymbolCache *semantic_cache,
WorkingFile *wfile, QueryFile *file) {
assert(file->def);
if (wfile->buffer_content.size() > g_config->largeFileSize ||
!semantic_cache->match_->IsMatch(file->def->path))
@ -208,86 +201,86 @@ void EmitSemanticHighlighting(DB* db,
StorageClass storage = SC_None;
// This switch statement also filters out symbols that are not highlighted.
switch (sym.kind) {
case SymbolKind::Func: {
const QueryFunc& func = db->GetFunc(sym);
const QueryFunc::Def* def = func.AnyDef();
if (!def)
continue; // applies to for loop
if (def->spell)
parent_kind = GetSymbolKind(db, *def->spell);
if (parent_kind == lsSymbolKind::Unknown) {
for (Use use : func.declarations) {
parent_kind = GetSymbolKind(db, use);
break;
}
case SymbolKind::Func: {
const QueryFunc &func = db->GetFunc(sym);
const QueryFunc::Def *def = func.AnyDef();
if (!def)
continue; // applies to for loop
if (def->spell)
parent_kind = GetSymbolKind(db, *def->spell);
if (parent_kind == lsSymbolKind::Unknown) {
for (Use use : func.declarations) {
parent_kind = GetSymbolKind(db, use);
break;
}
// Don't highlight overloadable operators or implicit lambda ->
// std::function constructor.
std::string_view short_name = def->Name(false);
if (short_name.compare(0, 8, "operator") == 0)
continue; // applies to for loop
if (def->spell)
parent_kind = GetSymbolKind(db, *def->spell);
kind = def->kind;
storage = def->storage;
detailed_name = short_name;
}
// Don't highlight overloadable operators or implicit lambda ->
// std::function constructor.
std::string_view short_name = def->Name(false);
if (short_name.compare(0, 8, "operator") == 0)
continue; // applies to for loop
if (def->spell)
parent_kind = GetSymbolKind(db, *def->spell);
kind = def->kind;
storage = def->storage;
detailed_name = short_name;
// Check whether the function name is actually there.
// If not, do not publish the semantic highlight.
// E.g. copy-initialization of constructors should not be highlighted
// but we still want to keep the range for jumping to definition.
std::string_view concise_name =
detailed_name.substr(0, detailed_name.find('<'));
int16_t start_line = sym.range.start.line;
int16_t start_col = sym.range.start.column;
if (start_line < 0 || start_line >= wfile->index_lines.size())
continue;
std::string_view line = wfile->index_lines[start_line];
sym.range.end.line = start_line;
if (!(start_col + concise_name.size() <= line.size() &&
line.compare(start_col, concise_name.size(), concise_name) == 0))
continue;
sym.range.end.column = start_col + concise_name.size();
break;
// Check whether the function name is actually there.
// If not, do not publish the semantic highlight.
// E.g. copy-initialization of constructors should not be highlighted
// but we still want to keep the range for jumping to definition.
std::string_view concise_name =
detailed_name.substr(0, detailed_name.find('<'));
int16_t start_line = sym.range.start.line;
int16_t start_col = sym.range.start.column;
if (start_line < 0 || start_line >= wfile->index_lines.size())
continue;
std::string_view line = wfile->index_lines[start_line];
sym.range.end.line = start_line;
if (!(start_col + concise_name.size() <= line.size() &&
line.compare(start_col, concise_name.size(), concise_name) == 0))
continue;
sym.range.end.column = start_col + concise_name.size();
break;
}
case SymbolKind::Type:
for (auto &def : db->GetType(sym).def) {
kind = def.kind;
detailed_name = def.detailed_name;
if (def.spell) {
parent_kind = GetSymbolKind(db, *def.spell);
break;
}
}
case SymbolKind::Type:
for (auto& def : db->GetType(sym).def) {
kind = def.kind;
detailed_name = def.detailed_name;
if (def.spell) {
parent_kind = GetSymbolKind(db, *def.spell);
break;
}
break;
case SymbolKind::Var: {
const QueryVar &var = db->GetVar(sym);
for (auto &def : var.def) {
kind = def.kind;
storage = def.storage;
detailed_name = def.detailed_name;
if (def.spell) {
parent_kind = GetSymbolKind(db, *def.spell);
break;
}
break;
case SymbolKind::Var: {
const QueryVar& var = db->GetVar(sym);
for (auto& def : var.def) {
kind = def.kind;
storage = def.storage;
detailed_name = def.detailed_name;
if (def.spell) {
parent_kind = GetSymbolKind(db, *def.spell);
break;
}
}
if (parent_kind == lsSymbolKind::Unknown) {
for (Use use : var.declarations) {
parent_kind = GetSymbolKind(db, use);
break;
}
}
break;
}
default:
continue; // applies to for loop
if (parent_kind == lsSymbolKind::Unknown) {
for (Use use : var.declarations) {
parent_kind = GetSymbolKind(db, use);
break;
}
}
break;
}
default:
continue; // applies to for loop
}
std::optional<lsRange> loc = GetLsRange(wfile, sym.range);
if (loc) {
auto it = grouped_symbols.find(sym);
if (it != grouped_symbols.end()) {
it->second.ranges.push_back(*loc);
it->second.lsRanges.push_back(*loc);
} else {
Out_CclsPublishSemanticHighlighting::Symbol symbol;
symbol.stableId = semantic_cache_for_file->GetStableId(
@ -295,7 +288,7 @@ void EmitSemanticHighlighting(DB* db,
symbol.parentKind = parent_kind;
symbol.kind = kind;
symbol.storage = storage;
symbol.ranges.push_back(*loc);
symbol.lsRanges.push_back(*loc);
grouped_symbols[sym] = symbol;
}
}
@ -304,9 +297,9 @@ void EmitSemanticHighlighting(DB* db,
// Make ranges non-overlapping using a scan line algorithm.
std::vector<ScanLineEvent> events;
int id = 0;
for (auto& entry : grouped_symbols) {
Out_CclsPublishSemanticHighlighting::Symbol& symbol = entry.second;
for (auto& loc : symbol.ranges) {
for (auto &entry : grouped_symbols) {
Out_CclsPublishSemanticHighlighting::Symbol &symbol = entry.second;
for (auto &loc : symbol.lsRanges) {
// For ranges sharing the same start point, the one with leftmost end
// point comes first.
events.push_back({loc.start, loc.end, id, &symbol});
@ -316,7 +309,7 @@ void EmitSemanticHighlighting(DB* db,
events.push_back({loc.end, loc.end, ~id, &symbol});
id++;
}
symbol.ranges.clear();
symbol.lsRanges.clear();
}
std::sort(events.begin(), events.end());
@ -332,19 +325,54 @@ void EmitSemanticHighlighting(DB* db,
// Attribute range [events[i-1].pos, events[i].pos) to events[top-1].symbol
// .
if (top && !(events[i - 1].pos == events[i].pos))
events[top - 1].symbol->ranges.push_back(
lsRange{events[i - 1].pos, events[i].pos});
events[top - 1].symbol->lsRanges.push_back(
{events[i - 1].pos, events[i].pos});
if (events[i].id >= 0)
events[top++] = events[i];
else
deleted[~events[i].id] = 1;
}
// Publish.
Out_CclsPublishSemanticHighlighting out;
out.params.uri = lsDocumentUri::FromPath(wfile->filename);
for (auto& entry : grouped_symbols)
// Transform lsRange into pair<int, int> (offset pairs)
{
std::vector<std::pair<lsRange, Out_CclsPublishSemanticHighlighting::Symbol *>>
scratch;
for (auto &entry : grouped_symbols)
for (auto &range : entry.second.lsRanges)
scratch.emplace_back(range, &entry.second);
std::sort(scratch.begin(), scratch.end(),
[](auto &l, auto &r) { return l.first.start < r.first.start; });
const auto &buf = wfile->buffer_content;
int l = 0, c = 0, i = 0;
auto mov = [&](int line, int col) {
if (l < line)
c = 0;
for (; l < line && i < buf.size(); i++)
if (buf[i] == '\n')
l++;
if (l < line) return true;
for (; c < col && i < buf.size(); c++)
if (uint8_t(buf[i++]) >= 128)
// Skip 0b10xxxxxx
while (i < buf.size() && uint8_t(buf[i]) >= 128 && uint8_t(buf[i]) < 192)
i++;
return c < col;
};
for (auto &entry : scratch) {
lsRange &r = entry.first;
if (mov(r.start.line, r.start.character))
continue;
int beg = i;
if (mov(r.end.line, r.end.character))
continue;
entry.second->ranges.emplace_back(beg, i);
}
}
for (auto &entry : grouped_symbols)
if (entry.second.ranges.size())
out.params.symbols.push_back(entry.second);
out.params.symbols.push_back(std::move(entry.second));
pipeline::WriteStdout(kMethodType_CclsPublishSemanticHighlighting, out);
}

5
src/message_handler.h
View File

@ -64,7 +64,10 @@ struct Out_CclsPublishSemanticHighlighting
lsSymbolKind parentKind;
lsSymbolKind kind;
clang::StorageClass storage;
std::vector<lsRange> ranges;
std::vector<std::pair<int, int>> ranges;
// `lsRanges` is used to compute `ranges`.
std::vector<lsRange> lsRanges;
};
struct Params {
lsDocumentUri uri;