void IndexerJob::superclassTemplateMemberFunctionUgleHack(const CXCursor &cursor, CXCursorKind kind,
const Location &location, const CXCursor &ref,
const CXCursor &parent)
{
// This is for references to superclass template functions. Awful awful
// shit. See https://github.com/Andersbakken/rtags/issues/62 and commit
// for details. I really should report this as a bug.
if (kind == CXCursor_MemberRefExpr && clang_getCursorKind(parent) == CXCursor_CallExpr) {
const CXCursor templateRef = RTags::findChild(cursor, CXCursor_TemplateRef);
if (templateRef == CXCursor_TemplateRef) {
const CXCursor classTemplate = clang_getCursorReferenced(templateRef);
if (classTemplate == CXCursor_ClassTemplate) {
FILE *f = fopen(location.path().constData(), "r");
if (f) {
const CXSourceRange range = clang_getCursorExtent(cursor);
const CXSourceLocation end = clang_getRangeEnd(range);
unsigned offset;
clang_getSpellingLocation(end, 0, 0, 0, &offset);
String name;
while (offset > 0) {
fseek(f, --offset, SEEK_SET);
char ch = static_cast<char>(fgetc(f));
if (isalnum(ch) || ch == '_' || ch == '~') {
name.prepend(ch);
} else {
break;
}
}
fclose(f);
if (!name.isEmpty()) {
RTags::Filter out;
out.kinds.insert(CXCursor_MemberRefExpr);
const int argCount = RTags::children(parent, RTags::Filter(), out).size();
RTags::Filter in(RTags::Filter::And);
in.names.insert(name);
in.argumentCount = argCount;
const List<CXCursor> alternatives = RTags::children(classTemplate, in);
switch (alternatives.size()) {
case 1:
handleReference(cursor, kind, Location(location.fileId(), offset + 1), alternatives.first(), parent);
break;
case 0:
break;
default:
warning() << "Can't decide which of these cursors are right for me"
<< cursor << alternatives
<< "Need to parse types";
break;
}
}
}
}
}
}
}
void DumpThread::checkIncludes(const Location &location, const CXCursor &cursor)
{
if (clang_getCursorKind(cursor) == CXCursor_InclusionDirective) {
handleInclude(location, cursor);
} else {
const CXCursor ref = clang_getCursorReferenced(cursor);
if (!clang_equalCursors(cursor, nullCursor) && !clang_equalCursors(cursor, ref)) {
handleReference(location, ref);
}
}
}
bool ClangIndexer::handleCursor(const CXCursor &cursor, CXCursorKind kind, const Location &location)
{
// error() << "Got a cursor" << cursor;
std::shared_ptr<CursorInfo> &info = mData->symbols[location];
if (!info)
info = std::make_shared<CursorInfo>();
if (!info->symbolLength) {
// if (mLogFile) {
// String out;
// Log(&out) << cursor << a;
// fwrite(out.constData(), 1, out.size(), mLogFile);
// fwrite("\n", 1, 1, mLogFile);
// }
CXStringScope name = clang_getCursorSpelling(cursor);
const char *cstr = name.data();
info->symbolLength = cstr ? strlen(cstr) : 0;
info->type = clang_getCursorType(cursor).kind;
if (!info->symbolLength) {
// this is for these constructs:
// typedef struct {
// int a;
// } foobar;
//
// We end up not getting a spelling for the cursor
switch (kind) {
case CXCursor_ClassDecl:
info->symbolLength = 5;
info->symbolName = "class";
break;
case CXCursor_UnionDecl:
info->symbolLength = 5;
info->symbolName = "union";
break;
case CXCursor_StructDecl:
info->symbolLength = 6;
info->symbolName = "struct";
break;
default:
mData->symbols.remove(location);
return false;
}
} else {
info->symbolName = addNamePermutations(cursor, location);
}
CXSourceRange range = clang_getCursorExtent(cursor);
CXSourceLocation rangeStart = clang_getRangeStart(range);
CXSourceLocation rangeEnd = clang_getRangeEnd(range);
unsigned startLine, startColumn, endLine, endColumn;
clang_getPresumedLocation(rangeStart, 0, &startLine, &startColumn);
clang_getPresumedLocation(rangeEnd, 0, &endLine, &endColumn);
info->startLine = startLine;
info->startColumn = startColumn;
info->endLine = endLine;
info->endColumn = endColumn;
if (kind == CXCursor_EnumConstantDecl) {
#if CINDEX_VERSION_MINOR > 1
info->enumValue = clang_getEnumConstantDeclValue(cursor);
#else
info->definition = 1;
#endif
} else {
info->definition = clang_isCursorDefinition(cursor);
}
info->kind = kind;
// apparently some function decls will give a different usr for
// their definition and their declaration. Using the canonical
// cursor's usr allows us to join them. Check JSClassRelease in
// JavaScriptCore for an example.
const String usr = RTags::eatString(clang_getCursorUSR(clang_getCanonicalCursor(cursor)));
if (!usr.isEmpty())
mData->usrMap[usr].insert(location);
switch (info->kind) {
case CXCursor_VarDecl: {
const CXCursor typeRef = resolveAutoTypeRef(cursor);
if (!clang_equalCursors(typeRef, nullCursor)) {
// const CXSourceRange range = clang_Cursor_getSpellingNameRange(mLastCursor, 0, 0);
// error() << "Found" << typeRef << "for" << cursor << mLastCursor
// << createLocation(mLastCursor)
// << clang_Range_isNull(range)
// << createLocation(clang_getCursorLocation(mLastCursor));
auto info = handleReference(mLastCursor, clang_getCursorKind(mLastCursor),
createLocation(clang_getCursorLocation(mLastCursor)),
clang_getCursorReferenced(typeRef), nullCursor);
if (info) {
// the type is read from the cursor passed in and that won't
// be correct in this case
info->type = clang_getCursorType(typeRef).kind;
info->symbolLength = 4;
info->symbolName += " (auto)";
info->endLine = info->startLine;
info->endColumn = info->startColumn + 4;
}
}
break; }
case CXCursor_Constructor:
case CXCursor_Destructor: {
Location parentLocation = createLocation(clang_getCursorSemanticParent(cursor));
// consider doing this for only declaration/inline definition since
// declaration and definition should know of one another
if (parentLocation.isValid()) {
std::shared_ptr<CursorInfo> &parent = mData->symbols[parentLocation];
if (!parent)
parent = std::make_shared<CursorInfo>();
parent->references.insert(location);
info->references.insert(parentLocation);
}
break; }
case CXCursor_CXXMethod: {
List<CursorInfo*> infos;
infos.append(info.get());
addOverriddenCursors(cursor, location, infos);
break; }
default:
break;
}
}
return true;
}
