CXChildVisitResult DumpThread::visitor(CXCursor cursor, CXCursor, CXClientData userData)
{
DumpThread *that = reinterpret_cast<DumpThread*>(userData);
assert(that);
CXSourceLocation location = clang_getCursorLocation(cursor);
if (!clang_equalLocations(location, nullLocation)) {
CXString file;
unsigned line, col;
clang_getPresumedLocation(location, &file, &line, &col);
Path path = RTags::eatString(file);
if (!path.isEmpty()) {
uint32_t &fileId = that->mFiles[path];
if (!fileId) {
const Path resolved = path.resolved();
fileId = Location::insertFile(resolved);
that->mFiles[path] = that->mFiles[resolved] = fileId;
}
if (that->mQueryFlags & QueryMessage::DumpIncludeHeaders || fileId == that->mSource.fileId) {
const Location loc(fileId, line, col);
String message;
message.reserve(256);
if (!(that->mQueryFlags & QueryMessage::NoContext))
message += loc.context();
CXSourceRange range = clang_getCursorExtent(cursor);
CXSourceLocation rangeEnd = clang_getRangeEnd(range);
unsigned endLine, endColumn;
clang_getPresumedLocation(rangeEnd, 0, &endLine, &endColumn);
if (endLine == line) {
message += String::format<32>(" // %d-%d, %d: ", col, endColumn, that->mIndentLevel);
} else {
message += String::format<32>(" // %d-%d:%d, %d: ", col, endLine, endColumn, that->mIndentLevel);
}
message += RTags::cursorToString(cursor, RTags::AllCursorToStringFlags);
message.append(" " + RTags::typeName(cursor) + " ");
CXCursor ref = clang_getCursorReferenced(cursor);
if (clang_equalCursors(ref, cursor)) {
message.append("refs self");
} else if (!clang_equalCursors(ref, nullCursor)) {
message.append("refs ");
message.append(RTags::cursorToString(ref, RTags::AllCursorToStringFlags));
}
CXCursor canonical = clang_getCanonicalCursor(cursor);
if (!clang_equalCursors(canonical, cursor) && !clang_equalCursors(canonical, nullCursor)) {
message.append("canonical ");
message.append(RTags::cursorToString(canonical, RTags::AllCursorToStringFlags));
}
that->writeToConnetion(message);
}
}
}
++that->mIndentLevel;
clang_visitChildren(cursor, DumpThread::visitor, userData);
--that->mIndentLevel;
return CXChildVisit_Continue;
}
void source_location::presumed_location(std::string *filename, unsigned *line, unsigned *column) const
{
if(filename)
{
CXString fn;
clang_getPresumedLocation(loc, &fn, line, column);
*filename = string(fn).str();
}
else
{
clang_getPresumedLocation(loc, nullptr, line, column);
}
}
CXChildVisitResult DumpThread::visit(const CXCursor &cursor)
{
if (isAborted())
return CXChildVisit_Break;
const Location location = createLocation(cursor);
if (!location.isNull()) {
if (mQueryFlags & QueryMessage::DumpCheckIncludes) {
checkIncludes(location, cursor);
return CXChildVisit_Recurse;
} else {
Flags<Location::ToStringFlag> locationFlags;
if (mQueryFlags & QueryMessage::NoColor)
locationFlags |= Location::NoColor;
CXSourceRange range = clang_getCursorExtent(cursor);
CXSourceLocation rangeEnd = clang_getRangeEnd(range);
unsigned int endLine, endColumn;
clang_getPresumedLocation(rangeEnd, 0, &endLine, &endColumn);
if (!(mQueryFlags & QueryMessage::DumpIncludeHeaders) && location.fileId() != mSource.fileId) {
return CXChildVisit_Continue;
}
String message;
message.reserve(256);
if (!(mQueryFlags & QueryMessage::NoContext)) {
message = location.context(locationFlags);
}
if (endLine == location.line()) {
message += String::format<32>(" // %d-%d, %d: ", location.column(), endColumn, mIndentLevel);
} else {
message += String::format<32>(" // %d-%d:%d, %d: ", location.column(), endLine, endColumn, mIndentLevel);
}
message += RTags::cursorToString(cursor, RTags::AllCursorToStringFlags);
message.append(" " + RTags::typeName(cursor));;
if (clang_getCursorKind(cursor) == CXCursor_VarDecl) {
const std::shared_ptr<RTags::Auto> autoResolved = RTags::resolveAuto(cursor);
if (autoResolved && !clang_equalCursors(autoResolved->cursor, nullCursor)) {
message += "auto resolves to " + RTags::cursorToString(autoResolved->cursor, RTags::AllCursorToStringFlags);
}
}
CXCursor ref = clang_getCursorReferenced(cursor);
if (clang_equalCursors(ref, cursor)) {
message.append("refs self");
} else if (!clang_equalCursors(ref, nullCursor)) {
message.append("refs ");
message.append(RTags::cursorToString(ref, RTags::AllCursorToStringFlags));
}
CXCursor canonical = clang_getCanonicalCursor(cursor);
if (!clang_equalCursors(canonical, cursor) && !clang_equalCursors(canonical, nullCursor)) {
message.append("canonical ");
message.append(RTags::cursorToString(canonical, RTags::AllCursorToStringFlags));
}
CXCursor specialized = clang_getSpecializedCursorTemplate(cursor);
if (!clang_equalCursors(specialized, cursor) && !clang_equalCursors(specialized, nullCursor)) {
message.append("specialized ");
message.append(RTags::cursorToString(specialized, RTags::AllCursorToStringFlags));
}
writeToConnetion(message);
}
}
++mIndentLevel;
clang_visitChildren(cursor, DumpThread::visitor, this);
if (isAborted())
return CXChildVisit_Break;
--mIndentLevel;
return CXChildVisit_Continue;
}
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_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;
}
void ClangIndexer::handleReference(const CXCursor &cursor, CXCursorKind kind, const Location &location, const CXCursor &ref, const CXCursor &parent)
{
const CXCursorKind refKind = clang_getCursorKind(ref);
if (clang_isInvalid(refKind)) {
superclassTemplateMemberFunctionUgleHack(cursor, kind, location, ref, parent);
return;
}
bool isOperator = false;
if (kind == CXCursor_CallExpr && (refKind == CXCursor_CXXMethod
|| refKind == CXCursor_ConversionFunction
|| refKind == CXCursor_FunctionDecl
|| refKind == CXCursor_FunctionTemplate)) {
// these are bullshit, for this construct:
// foo.bar();
// the position of the cursor is at the foo, not the bar.
// They are not interesting for followLocation, renameSymbol or find
// references so we toss them.
// For functions it can be the position of the namespace.
// E.g. Foo::bar(); cursor is on Foo
// For constructors they happen to be the only thing we have that
// actually refs the constructor and not the class so we have to keep
// them for that.
return;
}
switch (refKind) {
case CXCursor_Constructor:
if (isImplicit(ref))
return;
break;
case CXCursor_CXXMethod:
case CXCursor_FunctionDecl:
case CXCursor_FunctionTemplate: {
CXStringScope scope = clang_getCursorDisplayName(ref);
const char *data = scope.data();
if (data) {
const int len = strlen(data);
if (len > 8 && !strncmp(data, "operator", 8) && !isalnum(data[8]) && data[8] != '_') {
if (isImplicit(ref))
return; // eat implicit operator calls
isOperator = true;
}
}
break; }
default:
break;
}
const Location reffedLoc = createLocation(ref);
if (!reffedLoc.isValid()) {
if (kind == CXCursor_ObjCMessageExpr) {
mData->pendingReferenceMap[RTags::eatString(clang_getCursorUSR(clang_getCanonicalCursor(ref)))].insert(location);
// insert it, we'll hook up the target and references later
handleCursor(cursor, kind, location);
}
return;
}
std::shared_ptr<CursorInfo> &refInfo = mData->symbols[reffedLoc];
if ((!refInfo || !refInfo->symbolLength) && !handleCursor(ref, refKind, reffedLoc))
return;
refInfo->references.insert(location);
std::shared_ptr<CursorInfo> &info = mData->symbols[location];
if (!info)
info = std::make_shared<CursorInfo>();
info->targets.insert(reffedLoc);
// We need the new cursor to replace the symbolLength. This is important
// in the following case:
// struct R { R(const &r); ... }
// R foo();
// ...
// R r = foo();
// The first cursor on foo() will be a reference to the copy constructor and
// this cursor will have a symbolLength of 1. Thus you won't be able to jump
// to foo from the o. This is fixed by making sure the newer target, if
// better, gets to decide on the symbolLength
// The !isCursor is var decls and field decls where we set up a target even
// if they're not considered references
if (!RTags::isCursor(info->kind) && (!info->symbolLength || info->bestTarget(mData->symbols)->kind == refKind)) {
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;
info->definition = false;
info->kind = kind;
if (isOperator) {
unsigned start, end;
clang_getSpellingLocation(rangeStart, 0, 0, 0, &start);
clang_getSpellingLocation(rangeEnd, 0, 0, 0, &end);
info->symbolLength = end - start;
} else {
info->symbolLength = refInfo->symbolLength;
}
info->symbolName = refInfo->symbolName;
info->type = clang_getCursorType(cursor).kind;
}
}
bool ClangIndexer::diagnose()
{
if (!mClangUnit) {
return false;
}
List<String> compilationErrors;
const unsigned diagnosticCount = clang_getNumDiagnostics(mClangUnit);
Map<Location, XmlEntry> xmlEntries;
for (unsigned i=0; i<diagnosticCount; ++i) {
CXDiagnostic diagnostic = clang_getDiagnostic(mClangUnit, i);
const CXSourceLocation diagLoc = clang_getDiagnosticLocation(diagnostic);
const Location loc = createLocation(diagLoc, 0);
const uint32_t fileId = loc.fileId();
if (mData->visited.value(fileId)) {
const String msg = RTags::eatString(clang_getDiagnosticSpelling(diagnostic));
const CXDiagnosticSeverity sev = clang_getDiagnosticSeverity(diagnostic);
XmlEntry::Type type = XmlEntry::None;
switch (sev) {
case CXDiagnostic_Warning:
type = XmlEntry::Warning;
break;
case CXDiagnostic_Error:
case CXDiagnostic_Fatal:
type = XmlEntry::Error;
break;
default:
break;
}
if (type != XmlEntry::None) {
const unsigned rangeCount = clang_getDiagnosticNumRanges(diagnostic);
bool ok = false;
for (unsigned rangePos = 0; rangePos < rangeCount; ++rangePos) {
const CXSourceRange range = clang_getDiagnosticRange(diagnostic, rangePos);
const CXSourceLocation start = clang_getRangeStart(range);
const CXSourceLocation end = clang_getRangeEnd(range);
unsigned startOffset, endOffset;
clang_getSpellingLocation(start, 0, 0, 0, &startOffset);
clang_getSpellingLocation(end, 0, 0, 0, &endOffset);
if (!rangePos && !startOffset && !endOffset) {
// huh, range invalid? fall back to diag location
break;
} else {
unsigned int line, column;
clang_getPresumedLocation(start, 0, &line, &column);
const Location key(loc.fileId(), line, column);
xmlEntries[key] = XmlEntry(type, msg, endOffset - startOffset);
ok = true;
break;
}
}
if (!ok) {
unsigned line, column;
clang_getPresumedLocation(diagLoc, 0, &line, &column);
const Location key(loc.fileId(), line, column);
xmlEntries[key] = XmlEntry(type, msg);
// no length
}
}
// logDirect(RTags::CompilationError, msg.constData());
const unsigned fixItCount = clang_getDiagnosticNumFixIts(diagnostic);
for (unsigned f=0; f<fixItCount; ++f) {
CXSourceRange range;
const CXStringScope stringScope = clang_getDiagnosticFixIt(diagnostic, f, &range);
CXSourceLocation start = clang_getRangeStart(range);
unsigned line, column;
CXString file;
clang_getPresumedLocation(start, &file, &line, &column);
CXStringScope fileScope(file);
const Location loc = createLocation(clang_getCString(file), line, column);
if (mData->visited.value(loc.fileId())) {
unsigned int startOffset, endOffset;
CXSourceLocation end = clang_getRangeEnd(range);
clang_getSpellingLocation(start, 0, 0, 0, &startOffset);
clang_getSpellingLocation(end, 0, 0, 0, &endOffset);
const char *string = clang_getCString(stringScope);
error("Fixit for %s:%d:%d: Replace %d characters with [%s]", loc.path().constData(),
line, column, endOffset - startOffset, string);
XmlEntry &entry = xmlEntries[Location(loc.fileId(), line, column)];
entry.type = XmlEntry::Fixit;
if (entry.message.isEmpty()) {
entry.message = String::format<64>("did you mean '%s'?", string);
}
entry.length = endOffset - startOffset;
mData->fixIts[loc.fileId()].insert(FixIt(line, column, endOffset - startOffset, string));
}
}
}
clang_disposeDiagnostic(diagnostic);
}
mData->xmlDiagnostics = "<?xml version=\"1.0\" encoding=\"utf-8\"?><checkstyle>";
if (!xmlEntries.isEmpty()) {
Map<Location, XmlEntry>::const_iterator entry = xmlEntries.begin();
const Map<Location, XmlEntry>::const_iterator end = xmlEntries.end();
const char *severities[] = { "none", "warning", "error", "fixit" };
uint32_t lastFileId = 0;
while (entry != end) {
const Location &loc = entry->first;
const XmlEntry &xmlEntry = entry->second;
if (loc.fileId() != lastFileId) {
if (lastFileId)
mData->xmlDiagnostics += "</file>";
lastFileId = loc.fileId();
mData->xmlDiagnostics += String::format<128>("<file name=\"%s\">", loc.path().constData());
}
mData->xmlDiagnostics += String::format("<error line=\"%d\" column=\"%d\" %sseverity=\"%s\" message=\"%s\"/>",
loc.line(), loc.column(),
(xmlEntry.length <= 0 ? ""
: String::format<32>("length=\"%d\" ", xmlEntry.length).constData()),
severities[xmlEntry.type], xmlEscape(xmlEntry.message).constData());
++entry;
}
if (lastFileId)
mData->xmlDiagnostics += "</file>";
}
for (Hash<uint32_t, bool>::const_iterator it = mData->visited.begin(); it != mData->visited.end(); ++it) {
if (it->second) {
const Map<Location, XmlEntry>::const_iterator x = xmlEntries.lower_bound(Location(it->first, 0, 0));
if (x == xmlEntries.end() || x->first.fileId() != it->first) {
const String fn = Location::path(it->first);
mData->xmlDiagnostics += String::format("<file name=\"%s\"/>", fn.constData());
}
}
}
mData->xmlDiagnostics += "</checkstyle>";
return true;
}
