134 lines
5.0 KiB
C++
134 lines
5.0 KiB
C++
#pragma once
|
|
#include "LSPClient.h"
|
|
#include "PrimitivesRegistry.h"
|
|
#include <unordered_set>
|
|
#include <algorithm>
|
|
#include <cctype>
|
|
|
|
enum class CompletionContext {
|
|
General,
|
|
CppInclude
|
|
};
|
|
|
|
struct CompletionBuildResult {
|
|
std::vector<LSPClient::CompletionItem> items;
|
|
std::unordered_set<std::string> preferredNames;
|
|
};
|
|
|
|
static inline bool matchesPrefix(const std::string& text, const std::string& prefix) {
|
|
if (prefix.empty()) return true;
|
|
return text.rfind(prefix, 0) == 0;
|
|
}
|
|
|
|
static inline std::string trimLeft(const std::string& in) {
|
|
size_t i = 0;
|
|
while (i < in.size() && std::isspace(static_cast<unsigned char>(in[i]))) ++i;
|
|
return in.substr(i);
|
|
}
|
|
|
|
static inline std::string currentLinePrefix(const std::string& text, int cursor) {
|
|
if (cursor < 0) cursor = 0;
|
|
if (cursor > (int)text.size()) cursor = (int)text.size();
|
|
int lineStart = cursor;
|
|
while (lineStart > 0 && text[lineStart - 1] != '\n') --lineStart;
|
|
return text.substr(lineStart, cursor - lineStart);
|
|
}
|
|
|
|
static inline bool isCppLikeLanguage(const std::string& language) {
|
|
return language == "cpp" || language == "c";
|
|
}
|
|
|
|
static inline CompletionContext detectCompletionContext(const std::string& text,
|
|
int cursor,
|
|
const std::string& language) {
|
|
if (!isCppLikeLanguage(language)) return CompletionContext::General;
|
|
std::string line = trimLeft(currentLinePrefix(text, cursor));
|
|
if (line.rfind("#inc", 0) == 0 || line.rfind("#include", 0) == 0) {
|
|
return CompletionContext::CppInclude;
|
|
}
|
|
return CompletionContext::General;
|
|
}
|
|
|
|
static inline bool looksLikeIncludeCandidate(const LSPClient::CompletionItem& item) {
|
|
const std::string& label = item.label;
|
|
const std::string& filter = item.filterText.empty() ? item.label : item.filterText;
|
|
const std::string& insert = item.insertText.empty() ? item.label : item.insertText;
|
|
if (label.rfind("<", 0) == 0 || label.rfind("\"", 0) == 0) return true;
|
|
if (filter.rfind("<", 0) == 0 || filter.rfind("\"", 0) == 0) return true;
|
|
if (insert.rfind("<", 0) == 0 || insert.rfind("\"", 0) == 0) return true;
|
|
if (label.find(".h") != std::string::npos || filter.find(".h") != std::string::npos) return true;
|
|
if (label.find("/") != std::string::npos || filter.find("/") != std::string::npos) return true;
|
|
if (label == "include" || filter == "include") return true;
|
|
return false;
|
|
}
|
|
|
|
static inline std::vector<LSPClient::CompletionItem> includeSnippetCompletions() {
|
|
std::vector<LSPClient::CompletionItem> out;
|
|
auto add = [&](const std::string& label, const std::string& insert, const std::string& detail) {
|
|
LSPClient::CompletionItem ci;
|
|
ci.label = label;
|
|
ci.insertText = insert;
|
|
ci.filterText = label;
|
|
ci.detail = detail;
|
|
out.push_back(std::move(ci));
|
|
};
|
|
add("include", "include ", "preprocessor directive");
|
|
add("<string>", "<string>", "C++ header");
|
|
add("<vector>", "<vector>", "C++ header");
|
|
add("<iostream>", "<iostream>", "C++ header");
|
|
add("<memory>", "<memory>", "C++ header");
|
|
return out;
|
|
}
|
|
|
|
static inline CompletionBuildResult buildLibraryAwareCompletions(
|
|
const std::vector<LSPClient::CompletionItem>& lspItems,
|
|
const std::vector<PrimitiveSymbol>& primitives,
|
|
const std::string& prefix,
|
|
CompletionContext context = CompletionContext::General) {
|
|
CompletionBuildResult out;
|
|
if (context == CompletionContext::CppInclude) {
|
|
for (const auto& item : lspItems) {
|
|
if (looksLikeIncludeCandidate(item)) out.items.push_back(item);
|
|
}
|
|
} else {
|
|
out.items = lspItems;
|
|
}
|
|
|
|
std::unordered_set<std::string> existing;
|
|
for (const auto& item : out.items) {
|
|
existing.insert(item.label);
|
|
}
|
|
|
|
if (context == CompletionContext::CppInclude) {
|
|
for (const auto& ci : includeSnippetCompletions()) {
|
|
if (!matchesPrefix(ci.label, prefix)) continue;
|
|
if (existing.insert(ci.label).second) {
|
|
out.preferredNames.insert(ci.label);
|
|
out.items.push_back(ci);
|
|
}
|
|
}
|
|
} else {
|
|
for (const auto& prim : primitives) {
|
|
out.preferredNames.insert(prim.name);
|
|
if (!matchesPrefix(prim.name, prefix)) continue;
|
|
if (existing.insert(prim.name).second) {
|
|
LSPClient::CompletionItem ci;
|
|
ci.label = prim.name;
|
|
ci.insertText = prim.name;
|
|
ci.detail = prim.source;
|
|
out.items.push_back(std::move(ci));
|
|
}
|
|
}
|
|
}
|
|
|
|
std::stable_sort(out.items.begin(), out.items.end(),
|
|
[&](const LSPClient::CompletionItem& a, const LSPClient::CompletionItem& b) {
|
|
bool aPref = out.preferredNames.count(a.label) > 0;
|
|
bool bPref = out.preferredNames.count(b.label) > 0;
|
|
if (aPref != bPref) return aPref > bPref;
|
|
return a.label < b.label;
|
|
});
|
|
|
|
return out;
|
|
}
|