const char*
cc_result_entryname(CXCompletionString cs) {
int num = clang_getNumCompletionChunks(cs);
if(clang_getCompletionAvailability(cs) == CXAvailability_Available && num >= 1) {
int i;
for(i=0; i<num; i++) {
int type = clang_getCompletionChunkKind(cs, i);
if(type == CXCompletionChunk_TypedText){
CXString str = clang_getCompletionChunkText(cs, i);
return clang_getCString(str);
}
}
return NULL;
}else {
return NULL;
}
}
void CodeCompletionsExtractor::extractAvailability()
{
CXCompletionString cxCompletionString = cxCodeCompleteResults->Results[cxCodeCompleteResultIndex].CompletionString;
CXAvailabilityKind cxAvailabilityKind = clang_getCompletionAvailability(cxCompletionString);
switch (cxAvailabilityKind) {
case CXAvailability_Available:
currentCodeCompletion_.setAvailability(CodeCompletion::Available);
break;
case CXAvailability_Deprecated:
currentCodeCompletion_.setAvailability(CodeCompletion::Deprecated);
break;
case CXAvailability_NotAvailable:
currentCodeCompletion_.setAvailability(CodeCompletion::NotAvailable);
break;
case CXAvailability_NotAccessible:
currentCodeCompletion_.setAvailability(CodeCompletion::NotAccessible);
break;
}
}
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";
}
}
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);
if (cache->translationUnit && cache->source != request->source) {
clang_disposeTranslationUnit(cache->translationUnit);
cache->translationUnit = 0;
cache->source = request->source;
} else 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;
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 = sw.restart();
if (cache->translationUnit) {
RTags::reparseTranslationUnit(cache->translationUnit, &unsaved, request->unsaved.size() ? 1 : 0);
}
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 (%d) 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();
const unsigned int completionFlags = (CXCodeComplete_IncludeMacros|CXCodeComplete_IncludeCodePatterns);
CXCodeCompleteResults *results = clang_codeCompleteAt(cache->translationUnit, sourceFile.constData(),
request->location.line(), request->location.column(),
&unsaved, unsaved.Length ? 1 : 0, completionFlags);
completeTime = sw.restart();
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) && availabilityKind != CXAvailability_Available)
continue;
const int priority = clang_getCompletionPriority(string);
if (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.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) {
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.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 %d)",
sourceFile.constData(), parseTime, reparseTime, completeTime, processTime, nodeCount, request->unsaved.size());
} else {
printCompletions(List<Completions::Candidate>(), request);
error() << "No completion results available" << request->location << results->NumResults;
}
clang_disposeCodeCompleteResults(results);
}
}
CXAvailabilityKind code_completion_string::availability() const
{
return clang_getCompletionAvailability(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 CompletionJob::execute()
{
StopWatch timer;
CXUnsavedFile unsavedFile = { mUnsaved.isEmpty() ? 0 : mPath.constData(),
mUnsaved.isEmpty() ? 0 : mUnsaved.constData(),
static_cast<unsigned long>(mUnsaved.size()) };
if (!mUnit) {
String clangLine;
RTags::parseTranslationUnit(mPath, mArgs, mUnit, Server::instance()->clangIndex(), clangLine,
0, 0, &unsavedFile, 1);
mParseCount = 1;
if (!mUnit) {
error() << "Failed to parse" << mPath << "Can't complete";
return;
}
}
// error() << "Completing" << mPath << mParseCount;
assert(mParseCount >= 1 && mParseCount <= 2);
if (mParseCount == 1) {
RTags::reparseTranslationUnit(mUnit, &unsavedFile, 1);
if (!mUnit) {
mFinished(mPath, id());
return;
} else {
++mParseCount;
}
}
CXCodeCompleteResults *results = clang_codeCompleteAt(mUnit, mPath.constData(), mLine, mColumn,
&unsavedFile, mUnsaved.isEmpty() ? 0 : 1,
CXCodeComplete_IncludeMacros
| CXCodeComplete_IncludeCodePatterns);
if (results) {
CompletionNode *nodes = new CompletionNode[results->NumResults];
int nodeCount = 0;
Map<Token, int> tokens;
if (!mUnsaved.isEmpty()) {
tokenize(mUnsaved.constData(), mUnsaved.size(), tokens);
// 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 i = 0; i < results->NumResults; ++i) {
const CXCursorKind kind = results->Results[i].CursorKind;
if (kind == CXCursor_Destructor)
continue;
const CXCompletionString &string = results->Results[i].CompletionString;
const CXAvailabilityKind availabilityKind = clang_getCompletionAvailability(string);
if (availabilityKind != CXAvailability_Available)
continue;
const int priority = clang_getCompletionPriority(string);
if (priority >= 75)
continue;
CompletionNode &node = nodes[nodeCount];
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.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) {
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.value(Token(node.completion.constData(), node.completion.size()), -1);
++nodeCount;
continue;
}
}
node.completion.clear();
node.signature.clear();
}
if (nodeCount) {
if (nodeCount > SendThreshold) {
write("`");
} else {
qsort(nodes, nodeCount, sizeof(CompletionNode), compareCompletionNode);
if (mType == Stream) {
write<128>("`%s %s", nodes[0].completion.constData(), nodes[0].signature.constData());
} else {
write<128>("%s %s", nodes[0].completion.constData(), nodes[0].signature.constData());
}
for (int i=1; i<nodeCount; ++i) {
write<128>("%s %s", nodes[i].completion.constData(), nodes[i].signature.constData());
}
}
}
warning() << "Wrote" << ((nodeCount > SendThreshold) ? -1 : nodeCount) << "completions for"
<< String::format<128>("%s:%d:%d", mPath.constData(), mLine, mColumn)
<< "in" << timer.elapsed() << "ms" << mArgs;
// const unsigned diagnosticCount = clang_getNumDiagnostics(mUnit);
// for (unsigned i=0; i<diagnosticCount; ++i) {
// CXDiagnostic diagnostic = clang_getDiagnostic(mUnit, i);
// const CXDiagnosticSeverity severity = clang_getDiagnosticSeverity(diagnostic);
// const String msg = RTags::eatString(clang_getDiagnosticSpelling(diagnostic));
// CXFile file;
// unsigned line, col;
// clang_getSpellingLocation(clang_getDiagnosticLocation(diagnostic), &file, &line, &col, 0);
// error() << i << diagnosticCount << severity << msg
// << String::format<128>("%s:%d:%d", RTags::eatString(clang_getFileName(file)).constData(),
// line, col);
// clang_disposeDiagnostic(diagnostic);
// }
delete[] nodes;
//processDiagnostics(results);
clang_disposeCodeCompleteResults(results);
std::shared_ptr<Project> proj = project();
if (proj) {
// error() << "Adding to cache" << mParseCount << mPath;
proj->addToCache(mPath, mArgs, mUnit, mParseCount);
}
}
mFinished(mPath, id());
}
void CompletionJob::execute()
{
CXUnsavedFile unsavedFile = { mUnsaved.isEmpty() ? 0 : mPath.constData(),
mUnsaved.isEmpty() ? 0 : mUnsaved.constData(),
static_cast<unsigned long>(mUnsaved.size()) };
CXCodeCompleteResults *results = clang_codeCompleteAt(mUnit, mPath.constData(), mLine, mColumn,
&unsavedFile, mUnsaved.isEmpty() ? 0 : 1,
CXCodeComplete_IncludeMacros
| CXCodeComplete_IncludeCodePatterns);
if (results) {
CompletionNode *nodes = new CompletionNode[results->NumResults];
int nodeCount = 0;
Map<Token, int> tokens;
if (!mUnsaved.isEmpty()) {
tokenize(mUnsaved.constData(), mUnsaved.size(), tokens);
// for (Map<Token, int>::const_iterator it = tokens.begin(); it != tokens.end(); ++it) {
// error() << ByteArray(it->first.data, it->first.length) << it->second;
// }
}
for (unsigned i = 0; i < results->NumResults; ++i) {
const CXCursorKind kind = results->Results[i].CursorKind;
if (kind == CXCursor_Destructor)
continue;
const CXCompletionString &string = results->Results[i].CompletionString;
const CXAvailabilityKind availabilityKind = clang_getCompletionAvailability(string);
if (availabilityKind != CXAvailability_Available)
continue;
const int priority = clang_getCompletionPriority(string);
if (priority >= 75)
continue;
CompletionNode &node = nodes[nodeCount];
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.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) {
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.value(Token(node.completion.constData(), node.completion.size()), -1);
++nodeCount;
continue;
}
}
node.completion.clear();
node.signature.clear();
}
if (nodeCount) {
qsort(nodes, nodeCount, sizeof(CompletionNode), compareCompletionNode);
write<128>("`%s %s", nodes[0].completion.constData(), nodes[0].signature.constData());
for (int i=1; i<nodeCount; ++i) {
write<128>("%s %s", nodes[i].completion.constData(), nodes[i].signature.constData());
}
}
delete[] nodes;
//processDiagnostics(results);
clang_disposeCodeCompleteResults(results);
shared_ptr<Project> proj = project();
if (proj)
proj->addToCache(mPath, mArgs, mIndex, mUnit);
}
mFinished(mPath);
}
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);
}
}