CompletionData::CompletionData( const CXCompletionResult &completion_result ) {
CXCompletionString completion_string = completion_result.CompletionString;
if ( !completion_string )
return;
uint num_chunks = clang_getNumCompletionChunks( completion_string );
bool saw_left_paren = false;
bool saw_function_params = false;
bool saw_placeholder = false;
for ( uint j = 0; j < num_chunks; ++j ) {
ExtractDataFromChunk( completion_string,
j,
saw_left_paren,
saw_function_params,
saw_placeholder );
}
original_string_ = RemoveTrailingParens( boost::move( original_string_ ) );
kind_ = CursorKindToCompletionKind( completion_result.CursorKind );
detailed_info_.append( return_type_ )
.append( " " )
.append( everything_except_return_type_ )
.append( "\n" );
doc_string_ = YouCompleteMe::CXStringToString(
clang_getCompletionBriefComment( completion_string ) );
}
CompletionData::CompletionData( CXCompletionString completion_string,
CXCursorKind kind,
CXCodeCompleteResults *results,
size_t index ) {
size_t num_chunks = clang_getNumCompletionChunks( completion_string );
bool saw_left_paren = false;
bool saw_function_params = false;
bool saw_placeholder = false;
for ( size_t j = 0; j < num_chunks; ++j ) {
ExtractDataFromChunk( completion_string,
j,
saw_left_paren,
saw_function_params,
saw_placeholder );
}
original_string_ = RemoveTrailingParens( std::move( original_string_ ) );
kind_ = CursorKindToCompletionKind( kind );
detailed_info_.append( return_type_ )
.append( " " )
.append( everything_except_return_type_ )
.append( "\n" );
doc_string_ = CXStringToString(
clang_getCompletionBriefComment( completion_string ) );
BuildCompletionFixIt( results, index );
}
CompletionData::CompletionData( const CXCompletionResult &completion_result,
bool is_argument_hint ) {
CXCompletionString completion_string = completion_result.CompletionString;
if ( !completion_string )
return;
uint num_chunks = clang_getNumCompletionChunks( completion_string );
bool saw_left_paren = false;
bool saw_function_params = false;
bool saw_placeholder = false;
for ( uint j = 0; j < num_chunks; ++j ) {
ExtractDataFromChunk( completion_string,
j,
saw_left_paren,
saw_function_params,
saw_placeholder );
}
original_string_ = RemoveTrailingParens( boost::move( original_string_ ) );
kind_ = CursorKindToCompletionKind( completion_result.CursorKind );
// We trim any underscores from the function definition since identifiers
// with them are ugly, in most cases compiler-reserved names. Functions
// from the standard library use parameter names like "__pos" and we want to
// show them as just "pos". This will never interfere with client code since
// ANY C++ identifier with two consecutive underscores in it is
// compiler-reserved.
everything_except_return_type_ =
TrimUnderscores( everything_except_return_type_ );
detailed_info_.append( return_type_ )
.append( " " )
.append( everything_except_return_type_ )
.append( "\n" );
doc_string_ = YouCompleteMe::CXStringToString(
clang_getCompletionBriefComment( completion_string ) );
// This address issue #1287
if ( kind_ == YouCompleteMe::FUNCTION || kind_ == YouCompleteMe::UNKNOWN )
everything_except_return_type_ = original_string_;
if ( is_argument_hint ) {
kind_ = NONE;
return_type_ = "";
original_string_ = "";
everything_except_return_type_ = TrimUnderscores( current_arg_ );
if ( everything_except_return_type_.empty() )
everything_except_return_type_ = "void";
}
}
CompletionData::CompletionData( const CXCompletionResult &completion_result,
bool is_argument_hint ) {
CXCompletionString completion_string = completion_result.CompletionString;
if ( !completion_string )
return;
size_t num_chunks = clang_getNumCompletionChunks( completion_string );
bool saw_left_paren = false;
bool saw_function_params = false;
bool saw_placeholder = false;
for ( size_t j = 0; j < num_chunks; ++j ) {
ExtractDataFromChunk( completion_string,
j,
saw_left_paren,
saw_function_params,
saw_placeholder );
}
original_string_ = RemoveTrailingParens( std::move( original_string_ ) );
kind_ = CursorKindToCompletionKind( completion_result.CursorKind );
detailed_info_.append( return_type_ )
.append( " " )
.append( everything_except_return_type_ )
.append( "\n" );
doc_string_ = YouCompleteMe::CXStringToString(
clang_getCompletionBriefComment( completion_string ) );
// This address issue #1287
if ( kind_ == YouCompleteMe::FUNCTION || kind_ == YouCompleteMe::UNKNOWN )
everything_except_return_type_ = original_string_;
if ( is_argument_hint ) {
kind_ = NONE;
return_type_ = "";
original_string_ = "";
everything_except_return_type_ = current_arg_;
if ( everything_except_return_type_.empty() )
everything_except_return_type_ = "void";
}
}
/**
* ide_clang_completion_item_get_brief_comment:
* @self: An #IdeClangCompletionItem.
*
* Gets the brief comment that can be used to show extra information for the
* result.
*
* Returns: A string which should not be modified or freed.
*/
const gchar *
ide_clang_completion_item_get_brief_comment (IdeClangCompletionItem *self)
{
CXCompletionResult *result;
g_return_val_if_fail (IDE_IS_CLANG_COMPLETION_ITEM (self), NULL);
if (self->brief_comment == NULL)
{
CXString cxstr;
result = ide_clang_completion_item_get_result (self);
cxstr = clang_getCompletionBriefComment (result->CompletionString);
self->brief_comment = g_strdup (clang_getCString (cxstr));
clang_disposeString (cxstr);
}
return self->brief_comment;
}
void Irony::complete(const std::string &file,
unsigned line,
unsigned col,
const std::vector<std::string> &flags,
const std::vector<CXUnsavedFile> &unsavedFiles) {
CXTranslationUnit tu = tuManager_.getOrCreateTU(file, flags, unsavedFiles);
if (tu == nullptr) {
std::cout << "nil\n";
return;
}
if (CXCodeCompleteResults *completions =
clang_codeCompleteAt(tu,
file.c_str(),
line,
col,
const_cast<CXUnsavedFile *>(unsavedFiles.data()),
unsavedFiles.size(),
(clang_defaultCodeCompleteOptions() &
~CXCodeComplete_IncludeCodePatterns)
#if HAS_BRIEF_COMMENTS_IN_COMPLETION
|
CXCodeComplete_IncludeBriefComments
#endif
)) {
if (debug_) {
unsigned numDiags = clang_codeCompleteGetNumDiagnostics(completions);
std::clog << "debug: complete: " << numDiags << " diagnostic(s)\n";
for (unsigned i = 0; i < numDiags; ++i) {
CXDiagnostic diagnostic =
clang_codeCompleteGetDiagnostic(completions, i);
CXString s = clang_formatDiagnostic(
diagnostic, clang_defaultDiagnosticDisplayOptions());
std::clog << clang_getCString(s) << std::endl;
clang_disposeString(s);
clang_disposeDiagnostic(diagnostic);
}
}
clang_sortCodeCompletionResults(completions->Results,
completions->NumResults);
std::cout << "(\n";
// re-use the same buffers to avoid unnecessary allocations
std::string typedtext, brief, resultType, prototype, postCompCar;
std::vector<unsigned> postCompCdr;
for (unsigned i = 0; i < completions->NumResults; ++i) {
CXCompletionResult candidate = completions->Results[i];
CXAvailabilityKind availability =
clang_getCompletionAvailability(candidate.CompletionString);
unsigned priority =
clang_getCompletionPriority(candidate.CompletionString);
unsigned annotationStart = 0;
bool typedTextSet = false;
if (availability == CXAvailability_NotAccessible ||
availability == CXAvailability_NotAvailable) {
continue;
}
typedtext.clear();
brief.clear();
resultType.clear();
prototype.clear();
postCompCar.clear();
postCompCdr.clear();
for (CompletionChunk chunk(candidate.CompletionString); chunk.hasNext();
chunk.next()) {
char ch = 0;
auto chunkKind = chunk.kind();
switch (chunkKind) {
case CXCompletionChunk_ResultType:
resultType = chunk.text();
break;
case CXCompletionChunk_TypedText:
case CXCompletionChunk_Text:
case CXCompletionChunk_Placeholder:
case CXCompletionChunk_Informative:
case CXCompletionChunk_CurrentParameter:
prototype += chunk.text();
break;
case CXCompletionChunk_LeftParen: ch = '('; break;
case CXCompletionChunk_RightParen: ch = ')'; break;
case CXCompletionChunk_LeftBracket: ch = '['; break;
case CXCompletionChunk_RightBracket: ch = ']'; break;
case CXCompletionChunk_LeftBrace: ch = '{'; break;
case CXCompletionChunk_RightBrace: ch = '}'; break;
case CXCompletionChunk_LeftAngle: ch = '<'; break;
case CXCompletionChunk_RightAngle: ch = '>'; break;
case CXCompletionChunk_Comma: ch = ','; break;
case CXCompletionChunk_Colon: ch = ':'; break;
case CXCompletionChunk_SemiColon: ch = ';'; break;
case CXCompletionChunk_Equal: ch = '='; break;
case CXCompletionChunk_HorizontalSpace: ch = ' '; break;
case CXCompletionChunk_VerticalSpace: ch = '\n'; break;
case CXCompletionChunk_Optional:
// ignored for now
break;
}
if (ch != 0) {
prototype += ch;
// commas look better followed by a space
if (ch == ',') {
prototype += ' ';
}
}
if (typedTextSet) {
if (ch != 0) {
postCompCar += ch;
if (ch == ',') {
postCompCar += ' ';
}
} else if (chunkKind == CXCompletionChunk_Text ||
chunkKind == CXCompletionChunk_TypedText) {
postCompCar += chunk.text();
} else if (chunkKind == CXCompletionChunk_Placeholder ||
chunkKind == CXCompletionChunk_CurrentParameter) {
postCompCdr.push_back(postCompCar.size());
postCompCar += chunk.text();
postCompCdr.push_back(postCompCar.size());
}
}
// Consider only the first typed text. The CXCompletionChunk_TypedText
// doc suggests that exactly one typed text will be given but at least
// in Objective-C it seems that more than one can appear, see:
// https://github.com/Sarcasm/irony-mode/pull/78#issuecomment-37115538
if (chunkKind == CXCompletionChunk_TypedText && !typedTextSet) {
typedtext = chunk.text();
// annotation is what comes after the typedtext
annotationStart = prototype.size();
typedTextSet = true;
}
}
#if HAS_BRIEF_COMMENTS_IN_COMPLETION
brief = cxStringToStd(
clang_getCompletionBriefComment(candidate.CompletionString));
#endif
// see irony-completion.el#irony-completion-candidates
std::cout << '(' << support::quoted(typedtext) //
<< ' ' << priority //
<< ' ' << support::quoted(resultType) //
<< ' ' << support::quoted(brief) //
<< ' ' << support::quoted(prototype) //
<< ' ' << annotationStart //
<< " (" << support::quoted(postCompCar);
for (unsigned index : postCompCdr)
std::cout << ' ' << index;
std::cout << ")"
<< ")\n";
}
clang_disposeCodeCompleteResults(completions);
std::cout << ")\n";
}
}
std::string code_completion_string::briefComment() const
{
return string(clang_getCompletionBriefComment(str)).str();
}
completion_list translation_unit::complete_at(uint32_t row, uint32_t col) {
completion_list ret;
CXCodeCompleteResults *res;
if (mCxUnsaved) {
res = clang_codeCompleteAt(mUnit, mName.c_str(), row, col, mCxUnsaved, 1, 0);
}
else
res = clang_codeCompleteAt(mUnit, mName.c_str(), row, col, nullptr, 0, 0);
for (uint32_t i = 0; i < res->NumResults; ++i) {
// skip all private members
if (clang_getCompletionAvailability(res->Results[i].CompletionString) == CXAvailability_NotAccessible)
continue;
// number of completion chunks for the current result
completion_result r;
uint32_t nChunks = clang_getNumCompletionChunks(res->Results[i].CompletionString);
// function to handle a single chunk
auto handle_chunk = [&](CXCompletionChunkKind k, uint32_t num) {
CXString txt = clang_getCompletionChunkText(res->Results[i].CompletionString, num);
switch (k) {
case CXCompletionChunk_ResultType:
r.return_type = cx2std(txt);
break;
case CXCompletionChunk_TypedText:
r.name = cx2std(txt);
break;
case CXCompletionChunk_Placeholder:
r.args.push_back(cx2std(txt));
break;
case CXCompletionChunk_Optional:
case CXCompletionChunk_LeftParen:
case CXCompletionChunk_RightParen:
case CXCompletionChunk_RightBracket:
case CXCompletionChunk_LeftBracket:
case CXCompletionChunk_LeftBrace:
case CXCompletionChunk_RightBrace:
case CXCompletionChunk_RightAngle:
case CXCompletionChunk_LeftAngle:
case CXCompletionChunk_Comma:
case CXCompletionChunk_Colon:
case CXCompletionChunk_SemiColon:
case CXCompletionChunk_Equal:
case CXCompletionChunk_Informative:
case CXCompletionChunk_HorizontalSpace:
break;
default:
break;
}
};
for (uint32_t k = 0; k < nChunks; ++k) {
handle_chunk(clang_getCompletionChunkKind(res->Results[i].CompletionString, k), k);
}
// fill additional info and append to result set
r.brief = cx2std(clang_getCompletionBriefComment(res->Results[i].CompletionString));
r.priority = clang_getCompletionPriority(res->Results[i].CompletionString);
r.type = cursor2completion(res->Results[i].CursorKind);
// @todo: once clang forwards the CXCursor of a completion result, we should get
// the full documentation for each entry
ret.push_back(r);
}
clang_disposeCodeCompleteResults(res);
return ret;
}
void CompletionThread::process(Request *request)
{
// if (!request->unsaved.isEmpty()) {
// int line = request->location.line();
// int pos = 0;
// while (line > 1) {
// int p = request->unsaved.indexOf('\n', pos);
// if (p == -1) {
// pos = -1;
// break;
// }
// pos = p + 1;
// --line;
// }
// if (pos != -1) {
// int end = request->unsaved.indexOf('\n', pos);
// if (end == -1)
// end = request->unsaved.size();
// error("Completing at %s:%d:%d line: [%s]\n",
// request->location.path().constData(),
// request->location.line(),
// request->location.column(),
// request->unsaved.mid(pos, end - pos).constData());
// }
// }
StopWatch sw;
int parseTime = 0;
int reparseTime = 0;
int completeTime = 0;
int processTime = 0;
SourceFile *&cache = mCacheMap[request->source.fileId];
if (cache && cache->source != request->source) {
delete cache;
cache = 0;
}
if (!cache) {
cache = new SourceFile;
mCacheList.append(cache);
while (mCacheMap.size() > mCacheSize) {
SourceFile *c = mCacheList.removeFirst();
mCacheMap.remove(c->source.fileId);
delete c;
}
} else {
mCacheList.moveToEnd(cache);
}
const bool sendDebug = testLog(LogLevel::Debug);
assert(!cache->translationUnit || cache->source == request->source);
if (!cache->translationUnit) {
cache->source = request->source;
}
const Path sourceFile = request->source.sourceFile();
CXUnsavedFile unsaved = {
sourceFile.constData(),
request->unsaved.constData(),
static_cast<unsigned long>(request->unsaved.size())
};
size_t hash = 0;
uint64_t lastModified = 0;
if (request->unsaved.size()) {
std::hash<String> h;
hash = h(request->unsaved);
} else {
lastModified = sourceFile.lastModifiedMs();
}
const auto &options = Server::instance()->options();
if (!cache->translationUnit) {
cache->completionsMap.clear();
cache->completionsList.deleteAll();
sw.restart();
Flags<CXTranslationUnit_Flags> flags = static_cast<CXTranslationUnit_Flags>(clang_defaultEditingTranslationUnitOptions());
flags |= CXTranslationUnit_PrecompiledPreamble;
flags |= CXTranslationUnit_CacheCompletionResults;
flags |= CXTranslationUnit_SkipFunctionBodies;
flags |= CXTranslationUnit_DetailedPreprocessingRecord;
flags |= CXTranslationUnit_Incomplete;
flags |= CXTranslationUnit_IncludeBriefCommentsInCodeCompletion;
for (const auto &inc : options.includePaths) {
request->source.includePaths << inc;
}
request->source.defines << options.defines;
String clangLine;
RTags::parseTranslationUnit(sourceFile, request->source.toCommandLine(Source::Default|Source::ExcludeDefaultArguments),
cache->translationUnit, mIndex,
&unsaved, request->unsaved.size() ? 1 : 0, flags, &clangLine);
// error() << "PARSING" << clangLine;
parseTime = cache->parseTime = sw.restart();
if (cache->translationUnit) {
RTags::reparseTranslationUnit(cache->translationUnit, &unsaved, request->unsaved.size() ? 1 : 0);
}
reparseTime = cache->reparseTime = sw.elapsed();
if (!cache->translationUnit)
return;
cache->unsavedHash = hash;
cache->lastModified = lastModified;
} else if (cache->unsavedHash != hash || cache->lastModified != lastModified) {
cache->completionsMap.clear();
cache->completionsList.deleteAll();
cache->unsavedHash = hash;
cache->lastModified = lastModified;
} else if (!(request->flags & Refresh)) {
const auto it = cache->completionsMap.find(request->location);
if (it != cache->completionsMap.end()) {
cache->completionsList.moveToEnd(it->second);
error("Found completions (%zu) in cache %s:%d:%d",
it->second->candidates.size(), sourceFile.constData(),
request->location.line(), request->location.column());
printCompletions(it->second->candidates, request);
return;
}
}
sw.restart();
unsigned int completionFlags = (CXCodeComplete_IncludeCodePatterns|CXCodeComplete_IncludeBriefComments);
if (request->flags & CodeCompleteIncludeMacros)
completionFlags |= CXCodeComplete_IncludeMacros;
CXCodeCompleteResults *results = clang_codeCompleteAt(cache->translationUnit, sourceFile.constData(),
request->location.line(), request->location.column(),
&unsaved, unsaved.Length ? 1 : 0, completionFlags);
completeTime = cache->codeCompleteTime = sw.restart();
++cache->completions;
if (results) {
std::vector<Completions::Candidate> nodes;
nodes.reserve(results->NumResults);
int nodeCount = 0;
Map<Token, int> tokens;
if (!request->unsaved.isEmpty()) {
tokens = Token::tokenize(request->unsaved.constData(), request->unsaved.size());
// for (Map<Token, int>::const_iterator it = tokens.begin(); it != tokens.end(); ++it) {
// error() << String(it->first.data, it->first.length) << it->second;
// }
}
for (unsigned int i = 0; i < results->NumResults; ++i) {
const CXCursorKind kind = results->Results[i].CursorKind;
if (!(options.options & Server::CompletionsNoFilter) && kind == CXCursor_Destructor)
continue;
const CXCompletionString &string = results->Results[i].CompletionString;
const CXAvailabilityKind availabilityKind = clang_getCompletionAvailability(string);
if (!(options.options & Server::CompletionsNoFilter)) {
switch (availabilityKind) {
case CXAvailability_Available:
break;
case CXAvailability_Deprecated:
break;
case CXAvailability_NotAccessible:
break;
case CXAvailability_NotAvailable: // protected members are erroneously flagged as NotAvailable in clang 3.6
continue;
}
}
const int priority = clang_getCompletionPriority(string);
if (static_cast<size_t>(nodeCount) == nodes.size())
nodes.emplace_back();
Completions::Candidate &node = nodes.back();
node.cursorKind = kind;
node.priority = priority;
node.signature.reserve(256);
const int chunkCount = clang_getNumCompletionChunks(string);
bool ok = true;
for (int j=0; j<chunkCount; ++j) {
const CXCompletionChunkKind chunkKind = clang_getCompletionChunkKind(string, j);
if (chunkKind == CXCompletionChunk_TypedText) {
node.completion = RTags::eatString(clang_getCompletionChunkText(string, j));
if (node.completion.isEmpty()
|| (node.completion.size() > 8
&& node.completion.startsWith("operator")
&& !isPartOfSymbol(node.completion.at(8)))) {
ok = false;
break;
}
node.signature.append(node.completion);
} else {
node.signature.append(RTags::eatString(clang_getCompletionChunkText(string, j)));
if (chunkKind == CXCompletionChunk_ResultType)
node.signature.append(' ');
}
}
if (ok) {
const unsigned int annotations = clang_getCompletionNumAnnotations(string);
for (unsigned i=0; i<annotations; ++i) {
const CXStringScope annotation = clang_getCompletionAnnotation(string, i);
const char *cstr = clang_getCString(annotation);
if (const int len = strlen(cstr)) {
if (!node.annotation.isEmpty())
node.annotation.append(' ');
node.annotation.append(cstr, len);
}
}
node.parent = RTags::eatString(clang_getCompletionParent(string, 0));
node.briefComment = RTags::eatString(clang_getCompletionBriefComment(string));
int ws = node.completion.size() - 1;
while (ws >= 0 && isspace(node.completion.at(ws)))
--ws;
if (ws >= 0) {
node.completion.truncate(ws + 1);
node.signature.replace("\n", "");
node.distance = tokens.isEmpty() ? -1 : tokens.value(Token(node.completion.constData(), node.completion.size()), -1);
if (sendDebug)
debug() << node.signature << node.priority << kind
<< node.distance << clang_getCompletionAvailability(string);
++nodeCount;
continue;
}
}
node.completion.clear();
node.signature.clear();
}
if (nodeCount) {
// Sort pointers instead of shuffling candidates around
std::vector<Completions::Candidate*> nodesPtr;
nodesPtr.reserve(nodeCount);
for (auto& n : nodes) nodesPtr.push_back(&n);
std::sort(nodesPtr.begin(), nodesPtr.end(), compareCompletionCandidates);
Completions *&c = cache->completionsMap[request->location];
if (c) {
cache->completionsList.moveToEnd(c);
} else {
enum { MaxCompletionCache = 10 }; // ### configurable?
c = new Completions(request->location);
cache->completionsList.append(c);
while (cache->completionsMap.size() > MaxCompletionCache) {
Completions *cc = cache->completionsList.takeFirst();
cache->completionsMap.remove(cc->location);
delete cc;
}
}
c->candidates.resize(nodeCount);
for (int i=0; i<nodeCount; ++i)
c->candidates[i] = std::move(*nodesPtr[i]);
printCompletions(c->candidates, request);
processTime = sw.elapsed();
warning("Processed %s, parse %d/%d, complete %d, process %d => %d completions (unsaved %zu)%s",
request->location.toString().constData(),
parseTime, reparseTime, completeTime, processTime, nodeCount, request->unsaved.size(),
request->flags & Refresh ? " Refresh" : "");
} else {
printCompletions(List<Completions::Candidate>(), request);
error() << "No completion results available" << request->location << results->NumResults;
}
clang_disposeCodeCompleteResults(results);
}
}
QList<ClangCodeCompletionItem> TranslationUnit::completeAt(
const int line
, const int column
, const unsigned completion_flags
, const clang::unsaved_files_list& unsaved_files
, const PluginConfiguration::sanitize_rules_list_type& sanitize_rules
)
{
auto files = unsaved_files.get();
#ifndef NDEBUG
for (auto& item : files)
assert(
"Sanity check"
&& item.Filename
&& std::strlen(item.Filename)
&& item.Contents
&& item.Length
);
#endif
clang::DCXCodeCompleteResults res = {
clang_codeCompleteAt(
m_unit
, m_filename.constData()
, unsigned(line)
, unsigned(column)
, files.data()
, files.size()
, completion_flags
)
};
if (!res)
{
throw Exception::CompletionFailure(
i18nc("@item:intext", "Unable to perform code completion").toAscii().constData()
);
}
#if 0
clang_sortCodeCompletionResults(res->Results, res->NumResults);
#endif
// Collect some diagnostic SPAM
for (auto i = 0u; i < clang_codeCompleteGetNumDiagnostics(res); ++i)
{
clang::DCXDiagnostic diag = {clang_codeCompleteGetDiagnostic(res, i)};
appendDiagnostic(diag);
}
QList<ClangCodeCompletionItem> completions;
completions.reserve(res->NumResults); // Peallocate enough space for completion results
// Lets look what we've got...
for (auto i = 0u; i < res->NumResults; ++i)
{
const auto str = res->Results[i].CompletionString;
const auto priority = clang_getCompletionPriority(str);
const auto cursor_kind = res->Results[i].CursorKind;
debugShowCompletionResult(i, priority, str, cursor_kind);
// Skip unusable completions
// 0) check availability
const auto availability = clang_getCompletionAvailability(str);
if (availability != CXAvailability_Available && availability != CXAvailability_Deprecated)
{
kDebug(DEBUG_AREA) << "!! Skip result" << i << "as not available";
continue;
}
// 1) check usefulness
/// \todo Make it configurable
if (cursor_kind == CXCursor_NotImplemented)
continue;
// Collect all completion chunks and from a format string
QString text_before;
QString typed_text;
QString text_after;
QStringList placeholders;
int optional_placeholers_start_position = -1;
// A lambda to append given text to different parts
// of future completion string, depending on already processed text
auto appender = [&](const QString& text)
{
if (typed_text.isEmpty())
text_before += text;
else
text_after += text;
};
auto skip_this_item = false;
for (
auto j = 0u
, chunks = clang_getNumCompletionChunks(str)
; j < chunks && !skip_this_item
; ++j
)
{
auto kind = clang_getCompletionChunkKind(str, j);
auto text = toString(clang::DCXString{clang_getCompletionChunkText(str, j)});
switch (kind)
{
// Text that a user would be expected to type to get this code-completion result
case CXCompletionChunk_TypedText:
// Text that should be inserted as part of a code-completion result
case CXCompletionChunk_Text:
{
auto p = sanitize(text, sanitize_rules);// Pipe given piece of text through sanitizer
if (p.first)
typed_text += p.second;
else // Go for next completion item
skip_this_item = true;
break;
}
// Placeholder text that should be replaced by the user
case CXCompletionChunk_Placeholder:
{
auto p = sanitize(text, sanitize_rules);// Pipe given piece of text through sanitizer
if (p.first)
{
appender(
QLatin1String{"%"}
+ QString::number(placeholders.size() + 1)
+ QLatin1String{"%"}
);
placeholders.push_back(p.second);
}
else // Go for next completion item
skip_this_item = true;
break;
}
// A code-completion string that describes "optional" text that
// could be a part of the template (but is not required)
case CXCompletionChunk_Optional:
{
auto ostr = clang_getCompletionChunkCompletionString(str, j);
for (
auto oci = 0u
, ocn = clang_getNumCompletionChunks(ostr)
; oci < ocn
; ++oci
)
{
auto otext = toString(clang::DCXString{clang_getCompletionChunkText(ostr, oci)});
// Pipe given piece of text through sanitizer
auto p = sanitize(otext, sanitize_rules);
if (p.first)
{
auto okind = clang::kind_of(ostr, oci);
if (okind == CXCompletionChunk_Placeholder)
{
appender(
QLatin1String{"%"}
+ QString::number(placeholders.size() + 1)
+ QLatin1String{"%"}
);
placeholders.push_back(p.second);
optional_placeholers_start_position = placeholders.size();
}
else appender(p.second);
}
else
{
skip_this_item = true;
break;
}
}
break;
}
case CXCompletionChunk_ResultType:
case CXCompletionChunk_LeftParen:
case CXCompletionChunk_RightParen:
case CXCompletionChunk_LeftBracket:
case CXCompletionChunk_RightBracket:
case CXCompletionChunk_LeftBrace:
case CXCompletionChunk_RightBrace:
case CXCompletionChunk_LeftAngle:
case CXCompletionChunk_RightAngle:
case CXCompletionChunk_Comma:
case CXCompletionChunk_Colon:
case CXCompletionChunk_SemiColon:
case CXCompletionChunk_Equal:
case CXCompletionChunk_CurrentParameter:
case CXCompletionChunk_HorizontalSpace:
/// \todo Kate can't handle \c '\n' well in completions list
case CXCompletionChunk_VerticalSpace:
{
auto p = sanitize(text, sanitize_rules);// Pipe given piece of text through sanitizer
if (p.first)
appender(p.second);
else // Go for next completion item
skip_this_item = true;
break;
}
// Informative text that should be displayed but never inserted
// as part of the template
case CXCompletionChunk_Informative:
// Informative text before CXCompletionChunk_TypedText usually
// just a method scope (i.e. long name of an owner class)
// and it's useless for completer cuz it can group items
// by parent already...
if (!typed_text.isEmpty())
{
// Pipe given piece of text through sanitizer
auto p = sanitize(text, sanitize_rules);
if (p.first)
appender(p.second);
else // Go for next completion item
skip_this_item = true;
}
break;
default:
break;
}
}
// Does it pass the completion items sanitizer?
if (skip_this_item) continue; // No! Skip it!
assert("Priority expected to be less than 100" && priority < 101u);
const auto comment = toString(clang::DCXString{clang_getCompletionBriefComment(str)});
//
completions.push_back({
makeParentText(str, cursor_kind)
, text_before
, typed_text
, text_after
, placeholders
, optional_placeholers_start_position
, priority
, cursor_kind
, comment
, availability == CXAvailability_Deprecated
});
}
return completions;
}
void ClangDriver::OnPrepareTUEnded(wxCommandEvent& e)
{
// Our thread is done
m_isBusy = false;
// Sanity
ClangThreadReply* reply = (ClangThreadReply*)e.GetClientData();
if(!reply) {
return;
}
// Make sure we delete the reply at the end...
std::auto_ptr<ClangThreadReply> ap(reply);
// Delete the fake file...
DoDeleteTempFile(reply->filename);
// Just a notification without real info?
if(reply->context == CTX_None) {
return;
}
if(reply->context == ::CTX_CachePCH || reply->context == ::CTX_ReparseTU) {
return; // Nothing more to be done
}
if(reply->context == CTX_GotoDecl || reply->context == CTX_GotoImpl) {
// Unlike other context's the 'filename' specified here
// does not belong to an editor (it could, but it is not necessarily true)
DoGotoDefinition(reply);
return;
}
// Adjust the activeEditor to fit the filename
IEditor* editor = clMainFrame::Get()->GetMainBook()->FindEditor(reply->filename);
if(!editor) {
CL_DEBUG(wxT("Could not find an editor for file %s"), reply->filename.c_str());
return;
}
m_activeEditor = editor;
// What should we do with the TU?
switch(reply->context) {
case CTX_CachePCH:
// Nothing more to be done
return;
default:
break;
}
if(!reply->results && !reply->errorMessage.IsEmpty()) {
// Notify about this error
clCommandEvent event(wxEVT_CLANG_CODE_COMPLETE_MESSAGE);
event.SetString(reply->errorMessage);
event.SetInt(1); // indicates that this is an error message
EventNotifier::Get()->AddPendingEvent(event);
return;
}
if(m_activeEditor->GetCurrentPosition() < m_position) {
CL_DEBUG(wxT("Current position is lower than the starting position, ignoring completion"));
clang_disposeCodeCompleteResults(reply->results);
return;
}
wxString typedString;
if(m_activeEditor->GetCurrentPosition() > m_position) {
// User kept on typing while the completion thread was working
typedString = m_activeEditor->GetTextRange(m_position, m_activeEditor->GetCurrentPosition());
if(typedString.find_first_not_of(wxT("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_")) !=
wxString::npos) {
// User typed some non valid identifier char, cancel code completion
CL_DEBUG(
wxT("User typed: %s since the completion thread started working until it ended, ignoring completion"),
typedString.c_str());
clang_disposeCodeCompleteResults(reply->results);
return;
}
}
// update the filter word
reply->filterWord.Append(typedString);
CL_DEBUG(wxT("clang completion: filter word is %s"), reply->filterWord.c_str());
// For the Calltip, remove the opening brace from the filter string
wxString filterWord = reply->filterWord;
if(GetContext() == CTX_Calltip && filterWord.EndsWith(wxT("("))) filterWord.RemoveLast();
wxString lowerCaseFilter = filterWord;
lowerCaseFilter.MakeLower();
unsigned numResults = reply->results->NumResults;
clang_sortCodeCompletionResults(reply->results->Results, reply->results->NumResults);
std::vector<TagEntryPtr> tags;
for(unsigned i = 0; i < numResults; i++) {
CXCompletionResult result = reply->results->Results[i];
CXCompletionString str = result.CompletionString;
CXCursorKind kind = result.CursorKind;
if(kind == CXCursor_NotImplemented) continue;
wxString entryName, entrySignature, entryPattern, entryReturnValue;
DoParseCompletionString(str, 0, entryName, entrySignature, entryPattern, entryReturnValue);
wxString lowerCaseName = entryName;
lowerCaseName.MakeLower();
if(!lowerCaseFilter.IsEmpty() && !lowerCaseName.StartsWith(lowerCaseFilter)) continue;
if(clang_getCompletionAvailability(str) != CXAvailability_Available) continue;
TagEntry* t = new TagEntry();
TagEntryPtr tag(t);
tag->SetIsClangTag(true);
tag->SetName(entryName);
tag->SetPattern(entryPattern);
tag->SetSignature(entrySignature);
// Add support for clang comment parsing
#if HAS_LIBCLANG_BRIEFCOMMENTS
CXString BriefComment = clang_getCompletionBriefComment(str);
const char* comment = clang_getCString(BriefComment);
if(comment && comment[0] != '\0') {
tag->SetComment(wxString(comment, wxConvUTF8));
}
clang_disposeString(BriefComment);
#endif
switch(kind) {
case CXCursor_EnumConstantDecl:
tag->SetKind(wxT("enumerator"));
break;
case CXCursor_EnumDecl:
tag->SetKind(wxT("enum"));
break;
case CXCursor_CXXMethod:
case CXCursor_Constructor:
case CXCursor_Destructor:
case CXCursor_FunctionDecl:
case CXCursor_FunctionTemplate:
tag->SetKind(wxT("prototype"));
break;
case CXCursor_MacroDefinition:
tag->SetKind(wxT("macro"));
break;
case CXCursor_Namespace:
tag->SetKind(wxT("namespace"));
break;
case CXCursor_ClassDecl:
case CXCursor_ClassTemplate:
case CXCursor_ClassTemplatePartialSpecialization:
tag->SetKind(wxT("class"));
break;
case CXCursor_StructDecl:
tag->SetKind(wxT("struct"));
break;
case CXCursor_TypeRef:
case CXCursor_TypedefDecl:
tag->SetKind(wxT("typedef"));
tag->SetKind(wxT("typedef"));
break;
default:
tag->SetKind(wxT("variable"));
break;
}
tags.push_back(tag);
}
clang_disposeCodeCompleteResults(reply->results);
CL_DEBUG(wxT("Building completion results... done "));
if(GetContext() == CTX_Calltip) {
std::vector<TagEntryPtr> tips;
TagsManagerST::Get()->GetFunctionTipFromTags(tags, filterWord, tips);
m_activeEditor->ShowCalltip(new clCallTip(tips));
} else {
wxCodeCompletionBoxManager::Get().ShowCompletionBox(
m_activeEditor->GetCtrl(), tags, wxCodeCompletionBox::kNone, wxNOT_FOUND);
}
}
