std::string TranslationUnit::GetTypeAtLocation(
int line,
int column,
const std::vector< UnsavedFile > &unsaved_files,
bool reparse ) {
if ( reparse )
Reparse( unsaved_files );
unique_lock< mutex > lock( clang_access_mutex_ );
if ( !clang_translation_unit_ )
return "Internal error: no translation unit";
CXCursor cursor = GetCursor( line, column );
if ( !CursorIsValid( cursor ) )
return "Internal error: cursor not valid";
CXType type = clang_getCursorType( cursor );
std::string type_description =
CXStringToString( clang_getTypeSpelling( type ) );
if ( type_description.empty() )
return "Unknown type";
// We have a choice here; libClang provides clang_getCanonicalType which will
// return the "underlying" type for the type returned by clang_getCursorType
// e.g. for a typedef
// type = clang_getCanonicalType( type );
//
// Without the above, something like the following would return "MyType"
// rather than int:
// typedef int MyType;
// MyType i = 100; <-- type = MyType, canonical type = int
//
// There is probably more semantic value in calling it MyType. Indeed, if we
// opt for the more specific type, we can get very long or
// confusing STL types even for simple usage. e.g. the following:
// std::string test = "test"; <-- type = std::string;
// canonical type = std::basic_string<char>
//
// So as a compromise, we return both if and only if the types differ, like
// std::string => std::basic_string<char>
CXType canonical_type = clang_getCanonicalType( type );
if ( !clang_equalTypes( type, canonical_type ) ) {
type_description += " => ";
type_description += CXStringToString(
clang_getTypeSpelling( canonical_type ) );
}
return type_description;
}
std::string translation_unit::type_at(uint32_t row, uint32_t col) {
CXCursor cursor = get_cursor_at(row, col);
if (clang_Cursor_isNull(cursor) || clang_isInvalid(clang_getCursorKind(cursor)))
return "";
CXType type = clang_getCursorType(cursor);
CXType real_type = clang_getCanonicalType( type );
std::string ret = cx2std(clang_getTypeSpelling(type));
if (!clang_equalTypes(type, real_type)) {
ret.append(" - ");
ret.append(cx2std(clang_getTypeSpelling(real_type)));
}
return ret;
}
void Irony::getType(unsigned line, unsigned col) const {
if (activeTu_ == nullptr) {
std::clog << "W: get-type - parse wasn't called\n";
std::cout << "nil\n";
return;
}
CXFile cxFile = clang_getFile(activeTu_, file_.c_str());
CXSourceLocation sourceLoc = clang_getLocation(activeTu_, cxFile, line, col);
CXCursor cursor = clang_getCursor(activeTu_, sourceLoc);
if (clang_Cursor_isNull(cursor)) {
// TODO: "error: no type at point"?
std::cout << "nil";
return;
}
CXType cxTypes[2];
cxTypes[0] = clang_getCursorType(cursor);
cxTypes[1] = clang_getCanonicalType(cxTypes[0]);
std::cout << "(";
for (const CXType &cxType : cxTypes) {
CXString typeDescr = clang_getTypeSpelling(cxType);
std::string typeStr = clang_getCString(typeDescr);
clang_disposeString(typeDescr);
if (typeStr.empty())
break;
std::cout << support::quoted(typeStr) << " ";
}
std::cout << ")\n";
}
cursor::type cursor::type::canonical()
{
return { clang_getCanonicalType(ctype) };
}
Type Type::GetCanonical() const
{
return clang_getCanonicalType(type_);
}
static void PrintCursor(CXCursor Cursor) {
if (clang_isInvalid(Cursor.kind)) {
CXString ks = clang_getCursorKindSpelling(Cursor.kind);
printf("Invalid Cursor => %s", clang_getCString(ks));
clang_disposeString(ks);
}
else {
CXString string, ks;
CXCursor Referenced;
unsigned line, column;
CXCursor SpecializationOf;
ks = clang_getCursorKindSpelling(Cursor.kind);
string = clang_getCursorSpelling(Cursor);
printf("%s=%s", clang_getCString(ks),
clang_getCString(string));
clang_disposeString(ks);
clang_disposeString(string);
Referenced = clang_getCursorReferenced(Cursor);
if (!clang_equalCursors(Referenced, clang_getNullCursor())) {
CXSourceLocation Loc = clang_getCursorLocation(Referenced);
clang_getInstantiationLocation(Loc, 0, &line, &column, 0);
printf(":%d:%d", line, column);
}
if (clang_isCursorDefinition(Cursor))
printf(" (Definition)");
switch (clang_getCursorAvailability(Cursor)) {
case CXAvailability_Available:
break;
case CXAvailability_Deprecated:
printf(" (deprecated)");
break;
case CXAvailability_NotAvailable:
printf(" (unavailable)");
break;
}
if (Cursor.kind == CXCursor_IBOutletCollectionAttr) {
CXType T =
clang_getCanonicalType(clang_getIBOutletCollectionType(Cursor));
CXString S = clang_getTypeKindSpelling(T.kind);
printf(" [IBOutletCollection=%s]", clang_getCString(S));
clang_disposeString(S);
}
if (Cursor.kind == CXCursor_CXXBaseSpecifier) {
enum CX_CXXAccessSpecifier access = clang_getCXXAccessSpecifier(Cursor);
unsigned isVirtual = clang_isVirtualBase(Cursor);
const char *accessStr = 0;
switch (access) {
case CX_CXXInvalidAccessSpecifier:
accessStr = "invalid"; break;
case CX_CXXPublic:
accessStr = "public"; break;
case CX_CXXProtected:
accessStr = "protected"; break;
case CX_CXXPrivate:
accessStr = "private"; break;
}
printf(" [access=%s isVirtual=%s]", accessStr,
isVirtual ? "true" : "false");
}
SpecializationOf = clang_getSpecializedCursorTemplate(Cursor);
if (!clang_equalCursors(SpecializationOf, clang_getNullCursor())) {
CXSourceLocation Loc = clang_getCursorLocation(SpecializationOf);
CXString Name = clang_getCursorSpelling(SpecializationOf);
clang_getInstantiationLocation(Loc, 0, &line, &column, 0);
printf(" [Specialization of %s:%d:%d]",
clang_getCString(Name), line, column);
clang_disposeString(Name);
}
}
}
Type Type::canonical() const
{
return clang_getCanonicalType(m_cxType);
}
