ccls/src/indexer.cc

2233 lines
77 KiB
C++
Raw Normal View History

2017-02-22 08:52:00 +00:00
#include "indexer.h"
2017-02-17 09:57:44 +00:00
2018-05-27 19:24:56 +00:00
#include "log.hh"
2017-04-08 22:54:36 +00:00
#include "platform.h"
#include "serializer.h"
using ccls::Intern;
#include <clang/AST/AST.h>
#include <clang/Frontend/ASTUnit.h>
#include <llvm/Support/Timer.h>
using namespace clang;
using llvm::Timer;
#include <assert.h>
#include <inttypes.h>
2018-03-31 20:59:27 +00:00
#include <limits.h>
2017-04-22 07:39:55 +00:00
#include <algorithm>
#include <chrono>
#include <unordered_set>
2017-04-22 07:39:55 +00:00
#if CINDEX_VERSION >= 48
#define CINDEX_HAVE_ROLE 1
#endif
namespace {
2017-12-19 07:05:12 +00:00
// For typedef/using spanning less than or equal to (this number) of lines,
// display their declarations on hover.
constexpr int kMaxDetailedLines = 3;
struct CXTranslationUnitImpl {
/* clang::CIndexer */ void *CIdx;
clang::ASTUnit *TheASTUnit;
/* clang::cxstring::CXStringPool */ void *StringPool;
void *Diagnostics;
void *OverridenCursorsPool;
/* clang::index::CommentToXMLConverter */ void *CommentToXML;
unsigned ParsingOptions;
std::vector<std::string> Arguments;
};
2017-04-12 07:57:12 +00:00
// TODO How to check if a reference to type is a declaration?
// This currently also includes constructors/destructors.
// It seems declarations in functions are not indexed.
bool IsDeclContext(CXIdxEntityKind kind) {
switch (kind) {
case CXIdxEntity_CXXClass:
case CXIdxEntity_CXXNamespace:
case CXIdxEntity_ObjCCategory:
case CXIdxEntity_ObjCClass:
case CXIdxEntity_ObjCProtocol:
case CXIdxEntity_Struct:
return true;
default:
return false;
}
}
Role GetRole(const CXIdxEntityRefInfo* ref_info, Role role) {
#if CINDEX_HAVE_ROLE
return static_cast<Role>(static_cast<int>(ref_info->role));
#else
return role;
#endif
}
SymbolKind GetSymbolKind(CXCursorKind kind) {
switch (kind) {
2018-03-02 18:18:01 +00:00
case CXCursor_TranslationUnit:
return SymbolKind::File;
2018-02-22 07:34:32 +00:00
case CXCursor_FunctionDecl:
case CXCursor_CXXMethod:
case CXCursor_Constructor:
case CXCursor_Destructor:
case CXCursor_ConversionFunction:
case CXCursor_FunctionTemplate:
case CXCursor_OverloadedDeclRef:
case CXCursor_LambdaExpr:
case CXCursor_ObjCInstanceMethodDecl:
case CXCursor_ObjCClassMethodDecl:
2018-02-22 07:34:32 +00:00
return SymbolKind::Func;
case CXCursor_StructDecl:
case CXCursor_UnionDecl:
2018-02-22 07:34:32 +00:00
case CXCursor_ClassDecl:
case CXCursor_EnumDecl:
case CXCursor_ObjCInterfaceDecl:
case CXCursor_ObjCCategoryDecl:
case CXCursor_ObjCImplementationDecl:
case CXCursor_Namespace:
2018-02-22 07:34:32 +00:00
return SymbolKind::Type;
default:
return SymbolKind::Invalid;
}
}
// Inverse of libclang/CXIndexDataConsumer.cpp getEntityKindFromSymbolKind
lsSymbolKind GetSymbolKind(CXIdxEntityKind kind) {
2018-01-07 09:07:39 +00:00
switch (kind) {
case CXIdxEntity_Unexposed:
return lsSymbolKind::Unknown;
case CXIdxEntity_Typedef:
return lsSymbolKind::TypeAlias;
case CXIdxEntity_Function:
return lsSymbolKind::Function;
case CXIdxEntity_Variable:
// Can also be Parameter
return lsSymbolKind::Variable;
case CXIdxEntity_Field:
return lsSymbolKind::Field;
case CXIdxEntity_EnumConstant:
return lsSymbolKind::EnumMember;
case CXIdxEntity_ObjCClass:
return lsSymbolKind::Class;
case CXIdxEntity_ObjCProtocol:
return lsSymbolKind::Interface;
case CXIdxEntity_ObjCCategory:
return lsSymbolKind::Interface;
case CXIdxEntity_ObjCInstanceMethod:
return lsSymbolKind::Method;
case CXIdxEntity_ObjCClassMethod:
return lsSymbolKind::StaticMethod;
case CXIdxEntity_ObjCProperty:
return lsSymbolKind::Property;
case CXIdxEntity_ObjCIvar:
return lsSymbolKind::Field;
case CXIdxEntity_Enum:
return lsSymbolKind::Enum;
case CXIdxEntity_Struct:
case CXIdxEntity_Union:
return lsSymbolKind::Struct;
case CXIdxEntity_CXXClass:
return lsSymbolKind::Class;
case CXIdxEntity_CXXNamespace:
return lsSymbolKind::Namespace;
case CXIdxEntity_CXXNamespaceAlias:
return lsSymbolKind::Namespace;
case CXIdxEntity_CXXStaticVariable:
return lsSymbolKind::Field;
case CXIdxEntity_CXXStaticMethod:
return lsSymbolKind::StaticMethod;
case CXIdxEntity_CXXInstanceMethod:
return lsSymbolKind::Method;
case CXIdxEntity_CXXConstructor:
return lsSymbolKind::Constructor;
case CXIdxEntity_CXXDestructor:
return lsSymbolKind::Method;
case CXIdxEntity_CXXConversionFunction:
return lsSymbolKind::Constructor;
case CXIdxEntity_CXXTypeAlias:
return lsSymbolKind::TypeAlias;
case CXIdxEntity_CXXInterface:
return lsSymbolKind::Struct;
2018-01-07 09:07:39 +00:00
}
return lsSymbolKind::Unknown;
2018-01-07 09:07:39 +00:00
}
StorageClass GetStorageC(CX_StorageClass storage) {
switch (storage) {
default:
case CX_SC_Invalid:
case CX_SC_OpenCLWorkGroupLocal:
case CX_SC_None:
return SC_None;
case CX_SC_Extern:
return SC_Extern;
case CX_SC_Static:
return SC_Static;
case CX_SC_PrivateExtern:
return SC_PrivateExtern;
case CX_SC_Auto:
return SC_Auto;
case CX_SC_Register:
return SC_Register;
}
}
// Caches all instances of constructors, regardless if they are indexed or not.
// The constructor may have a make_unique call associated with it that we need
// to export. If we do not capture the parameter type description for the
// constructor we will not be able to attribute the constructor call correctly.
struct ConstructorCache {
struct Constructor {
2018-01-13 08:10:39 +00:00
Usr usr;
std::vector<std::string> param_type_desc;
};
2018-01-13 08:10:39 +00:00
std::unordered_map<Usr, std::vector<Constructor>> constructors_;
// This should be called whenever there is a constructor declaration.
void NotifyConstructor(ClangCursor ctor_cursor) {
auto build_type_desc = [](ClangCursor cursor) {
std::vector<std::string> type_desc;
for (ClangCursor arg : cursor.get_arguments()) {
if (arg.get_kind() == CXCursor_ParmDecl)
type_desc.push_back(arg.get_type_description());
}
return type_desc;
};
Constructor ctor{ctor_cursor.get_usr_hash(), build_type_desc(ctor_cursor)};
// Insert into |constructors_|.
auto type_usr_hash = ctor_cursor.get_semantic_parent().get_usr_hash();
auto existing_ctors = constructors_.find(type_usr_hash);
if (existing_ctors != constructors_.end()) {
existing_ctors->second.push_back(ctor);
} else {
constructors_[type_usr_hash] = {ctor};
}
}
// Tries to lookup a constructor in |type_usr| that takes arguments most
// closely aligned to |param_type_desc|.
2018-03-31 03:16:33 +00:00
std::optional<Usr> TryFindConstructorUsr(
2018-01-13 08:10:39 +00:00
Usr type_usr,
const std::vector<std::string>& param_type_desc) {
auto count_matching_prefix_length = [](const char* a, const char* b) {
int matched = 0;
while (*a && *b) {
if (*a != *b)
break;
++a;
++b;
++matched;
}
// Additional score if the strings were the same length, which makes
// "a"/"a" match higher than "a"/"a&"
if (*a == *b)
matched += 1;
return matched;
};
// Try to find constructors for the type. If there are no constructors
// available, return an empty result.
auto ctors_it = constructors_.find(type_usr);
if (ctors_it == constructors_.end())
2018-03-31 03:16:33 +00:00
return std::nullopt;
const std::vector<Constructor>& ctors = ctors_it->second;
if (ctors.empty())
2018-03-31 03:16:33 +00:00
return std::nullopt;
2018-01-15 16:57:47 +00:00
Usr best_usr = ctors[0].usr;
int best_score = INT_MIN;
// Scan constructors for the best possible match.
for (const Constructor& ctor : ctors) {
// If |param_type_desc| is empty and the constructor is as well, we don't
// need to bother searching, as this is the match.
if (param_type_desc.empty() && ctor.param_type_desc.empty()) {
best_usr = ctor.usr;
break;
}
// Weight matching parameter length heavily, as it is more accurate than
// the fuzzy type matching approach.
int score = 0;
if (param_type_desc.size() == ctor.param_type_desc.size())
score += param_type_desc.size() * 1000;
// Do prefix-based match on parameter type description. This works well in
// practice because clang appends qualifiers to the end of the type, ie,
// |foo *&&|
for (size_t i = 0;
i < std::min(param_type_desc.size(), ctor.param_type_desc.size());
++i) {
score += count_matching_prefix_length(param_type_desc[i].c_str(),
ctor.param_type_desc[i].c_str());
}
if (score > best_score) {
best_usr = ctor.usr;
best_score = score;
}
}
return best_usr;
}
};
struct IndexParam {
2017-07-30 04:24:02 +00:00
std::unordered_set<CXFile> seen_cx_files;
std::vector<std::string> seen_files;
std::unordered_map<std::string, FileContents> file_contents;
std::unordered_map<std::string, int64_t> file2write_time;
2017-07-30 04:24:02 +00:00
// Only use this when strictly needed (ie, primary translation unit is
// needed). Most logic should get the IndexFile instance via
// |file_consumer|.
//
// This can be null if we're not generating an index for the primary
// translation unit.
IndexFile* primary_file = nullptr;
ClangTranslationUnit* tu = nullptr;
FileConsumer* file_consumer = nullptr;
NamespaceHelper ns;
ConstructorCache ctors;
IndexParam(ClangTranslationUnit* tu, FileConsumer* file_consumer)
2018-04-04 06:05:41 +00:00
: tu(tu), file_consumer(file_consumer) {}
std::tuple<std::string, int16_t, int16_t, int16_t> PrettyPrintCursor(
CXCursor Cursor,
std::string_view short_name) {
auto TU =
static_cast<CXTranslationUnitImpl*>(const_cast<void*>(Cursor.data[2]));
ASTContext& AST = TU->TheASTUnit->getASTContext();
PrintingPolicy Policy = AST.getPrintingPolicy();
Policy.TerseOutput = 1;
Policy.FullyQualifiedName = true;
const Decl* D = static_cast<const Decl*>(Cursor.data[0]);
if (!D)
return {"", 0, 0, 0};
llvm::SmallString<128> Str;
llvm::raw_svector_ostream OS(Str);
D->print(OS, Policy);
std::string name = OS.str();
for (std::string::size_type i = 0;;) {
if ((i = name.find("(anonymous ", i)) == std::string::npos)
break;
i++;
if (name.size() > 10 + 9 && name.compare(10, 9, "namespace"))
name.replace(i, 10 + 9, "anon ns");
else
name.replace(i, 10, "anon");
}
auto i = name.find(short_name);
assert(i != std::string::npos);
int16_t short_name_offset = i, short_name_size = short_name.size();
for (int paren = 0; i; i--) {
// Skip parentheses in "(anon struct)::name"
if (name[i - 1] == ')')
paren++;
else if (name[i - 1] == '(')
paren--;
else if (!(paren > 0 || isalnum(name[i - 1]) ||
name[i - 1] == '_' || name[i - 1] == ':'))
break;
}
return {name, i, short_name_offset, short_name_size};
}
};
IndexFile* ConsumeFile(IndexParam* param, CXFile file) {
if (!file)
return nullptr;
bool is_first_ownership = false;
IndexFile* db = param->file_consumer->TryConsumeFile(
file, &is_first_ownership, &param->file_contents);
2017-07-30 04:24:02 +00:00
// If this is the first time we have seen the file (ignoring if we are
// generating an index for it):
if (param->seen_cx_files.insert(file).second) {
std::string file_name = FileName(file);
// file_name may be empty when it contains .. and is outside of WorkingDir.
2018-02-22 07:34:32 +00:00
// https://reviews.llvm.org/D42893
// https://github.com/cquery-project/cquery/issues/413
2017-08-16 03:28:52 +00:00
if (!file_name.empty()) {
// Add to all files we have seen so we can generate proper dependency
// graph.
param->seen_files.push_back(file_name);
// Set modification time.
std::optional<int64_t> write_time = LastWriteTime(file_name);
LOG_IF_S(ERROR, !write_time) << "failed to fetch write time for "
<< file_name;
if (write_time)
param->file2write_time[file_name] = *write_time;
2017-07-30 04:24:02 +00:00
}
}
if (is_first_ownership) {
// Report skipped source range list.
CXSourceRangeList* skipped = clang_getSkippedRanges(param->tu->cx_tu, file);
for (unsigned i = 0; i < skipped->count; ++i) {
db->skipped_by_preprocessor.push_back(
ResolveCXSourceRange(skipped->ranges[i]));
}
clang_disposeSourceRangeList(skipped);
}
return db;
}
2017-05-23 06:47:27 +00:00
// Returns true if the given entity kind can be called implicitly, ie, without
// actually being written in the source code.
bool CanBeCalledImplicitly(CXIdxEntityKind kind) {
switch (kind) {
2017-09-22 01:14:57 +00:00
case CXIdxEntity_CXXConstructor:
case CXIdxEntity_CXXConversionFunction:
case CXIdxEntity_CXXDestructor:
return true;
default:
return false;
2017-05-23 06:47:27 +00:00
}
}
// Returns true if the cursor spelling contains the given string. This is
// useful to check for implicit function calls.
2017-09-22 01:14:57 +00:00
bool CursorSpellingContainsString(CXCursor cursor,
CXTranslationUnit cx_tu,
std::string_view needle) {
2017-05-23 06:47:27 +00:00
CXSourceRange range = clang_Cursor_getSpellingNameRange(cursor, 0, 0);
CXToken* tokens;
unsigned num_tokens;
2017-05-23 06:47:27 +00:00
clang_tokenize(cx_tu, range, &tokens, &num_tokens);
bool result = false;
for (unsigned i = 0; i < num_tokens; ++i) {
2017-05-23 06:47:27 +00:00
CXString name = clang_getTokenSpelling(cx_tu, tokens[i]);
if (needle == clang_getCString(name)) {
2017-05-23 06:47:27 +00:00
result = true;
break;
}
clang_disposeString(name);
}
clang_disposeTokens(cx_tu, tokens, num_tokens);
return result;
}
// Returns the document content for the given range. May not work perfectly
// when there are tabs instead of spaces.
2017-09-22 01:14:57 +00:00
std::string GetDocumentContentInRange(CXTranslationUnit cx_tu,
CXSourceRange range) {
std::string result;
CXToken* tokens;
unsigned num_tokens;
clang_tokenize(cx_tu, range, &tokens, &num_tokens);
2018-03-31 03:16:33 +00:00
std::optional<Range> previous_token_range;
for (unsigned i = 0; i < num_tokens; ++i) {
// Add whitespace between the previous token and this one.
2018-01-11 02:43:01 +00:00
Range token_range =
ResolveCXSourceRange(clang_getTokenExtent(cx_tu, tokens[i]));
if (previous_token_range) {
// Insert newlines.
2017-09-22 01:14:57 +00:00
int16_t line_delta =
token_range.start.line - previous_token_range->end.line;
assert(line_delta >= 0);
if (line_delta > 0) {
result.append((size_t)line_delta, '\n');
// Reset column so we insert starting padding.
previous_token_range->end.column = 0;
}
// Insert spaces.
2017-09-22 01:14:57 +00:00
int16_t column_delta =
token_range.start.column - previous_token_range->end.column;
assert(column_delta >= 0);
result.append((size_t)column_delta, ' ');
}
previous_token_range = token_range;
// Add token content.
CXString spelling = clang_getTokenSpelling(cx_tu, tokens[i]);
result += clang_getCString(spelling);
clang_disposeString(spelling);
}
clang_disposeTokens(cx_tu, tokens, num_tokens);
return result;
}
// |parent| should be resolved before using |SetUsePreflight| so that |def| will
// not be invalidated by |To{Func,Type,Var}Id|.
2018-02-18 18:07:13 +00:00
Use SetUse(IndexFile* db, Range range, ClangCursor parent, Role role) {
switch (GetSymbolKind(parent.get_kind())) {
case SymbolKind::Func:
return Use{{range, db->ToFunc(parent).usr, SymbolKind::Func, role}};
case SymbolKind::Type:
return Use{{range, db->ToType(parent).usr, SymbolKind::Type, role}};
case SymbolKind::Var:
return Use{{range, db->ToVar(parent).usr, SymbolKind::Var, role}};
2018-02-18 18:07:13 +00:00
default:
return Use{{range, 0, SymbolKind::File, role}};
}
}
const char* GetAnonName(CXCursorKind kind) {
switch (kind) {
2018-03-20 02:51:42 +00:00
case CXCursor_ClassDecl:
return "(anon class)";
case CXCursor_EnumDecl:
return "(anon enum)";
case CXCursor_Namespace:
return "(anon ns)";
2018-03-20 02:51:42 +00:00
case CXCursor_StructDecl:
return "(anon struct)";
case CXCursor_UnionDecl:
return "(anon union)";
default:
return "(anon)";
}
}
void SetTypeName(IndexType& type,
2018-01-26 06:20:28 +00:00
const ClangCursor& cursor,
const CXIdxContainerInfo* container,
const char* name,
IndexParam* param) {
2018-01-26 06:20:28 +00:00
CXIdxContainerInfo parent;
// |name| can be null in an anonymous struct (see
// tests/types/anonymous_struct.cc).
if (!name)
name = GetAnonName(cursor.get_kind());
2018-01-26 06:20:28 +00:00
if (!container)
parent.cursor = cursor.get_semantic_parent().cx_cursor;
2018-02-22 07:34:32 +00:00
// Investigate why clang_getCursorPrettyPrinted gives `struct A {}` `namespace
// ns {}` which are not qualified.
// type->def.detailed_name = param->PrettyPrintCursor(cursor.cx_cursor);
int short_name_offset, short_name_size;
std::string detailed;
std::tie(detailed, short_name_offset, short_name_size) =
2018-02-22 07:34:32 +00:00
param->ns.QualifiedName(container ? container : &parent, name);
type.def.detailed_name = Intern(detailed);
type.def.qual_name_offset = 0;
type.def.short_name_offset = short_name_offset;
type.def.short_name_size = short_name_size;
}
// Finds the cursor associated with the declaration type of |cursor|. This
// strips
// qualifies from |cursor| (ie, Foo* => Foo) and removes template arguments
// (ie, Foo<A,B> => Foo<*,*>).
IndexType* ResolveToDeclarationType(IndexFile* db,
ClangCursor cursor,
IndexParam* param) {
ClangType type = cursor.get_type();
// auto x = new Foo() will not be deduced to |Foo| if we do not use the
// canonical type. However, a canonical type will look past typedefs so we
// will not accurately report variables on typedefs if we always do this.
if (type.cx_type.kind == CXType_Auto)
type = type.get_canonical();
type = type.strip_qualifiers();
if (type.is_builtin()) {
// For builtin types, use type kinds as USR hash.
return &db->ToType(static_cast<Usr>(type.cx_type.kind));
}
ClangCursor declaration =
2018-01-21 06:55:29 +00:00
type.get_declaration().template_specialization_to_template_definition();
2018-05-09 05:01:58 +00:00
std::optional<Usr> usr = declaration.get_opt_usr_hash();
if (!usr)
return nullptr;
2018-05-09 05:01:58 +00:00
IndexType& typ = db->ToType(*usr);
if (!typ.def.detailed_name[0]) {
2018-02-18 18:07:13 +00:00
std::string name = declaration.get_spell_name();
SetTypeName(typ, declaration, nullptr, name.c_str(), param);
}
return &typ;
}
void SetVarDetail(IndexVar& var,
std::string_view short_name,
const ClangCursor& cursor,
const CXIdxContainerInfo* semanticContainer,
bool is_first_seen,
IndexFile* db,
IndexParam* param) {
IndexVar::Def& def = var.def;
const CXType cx_type = clang_getCursorType(cursor.cx_cursor);
std::string type_name = ToString(clang_getTypeSpelling(cx_type));
// clang may report "(lambda at foo.cc)" which end up being a very long
// string. Shorten it to just "lambda".
if (type_name.find("(lambda at") != std::string::npos)
type_name = "lambda";
2018-04-04 06:05:41 +00:00
if (g_config->index.comments)
def.comments = Intern(cursor.get_comments());
def.storage = GetStorageC(clang_Cursor_getStorageClass(cursor.cx_cursor));
// TODO how to make PrettyPrint'ed variable name qualified?
#if 0 && CINDEX_HAVE_PRETTY
cursor.get_kind() != CXCursor_EnumConstantDecl
? param->PrettyPrintCursor(cursor.cx_cursor)
:
#endif
std::string qualified_name;
std::tie(qualified_name, def.short_name_offset, def.short_name_size) =
param->ns.QualifiedName(semanticContainer, short_name);
2018-01-17 03:09:29 +00:00
2018-01-18 10:59:51 +00:00
if (cursor.get_kind() == CXCursor_EnumConstantDecl && semanticContainer) {
2018-05-09 05:01:58 +00:00
CXTypeKind k = clang_getCanonicalType(
clang_getEnumDeclIntegerType(semanticContainer->cursor))
.kind;
std::string hover = qualified_name;
if (auto* TD = dyn_cast_or_null<EnumConstantDecl>(
static_cast<const Decl*>(cursor.cx_cursor.data[0]))) {
hover += " = ";
if (k == CXType_Char_U || k == CXType_UChar || k == CXType_UShort ||
k == CXType_UInt || k == CXType_ULong || k == CXType_ULongLong)
hover += std::to_string(TD->getInitVal().getZExtValue());
else
hover += std::to_string(TD->getInitVal().getSExtValue());
}
def.detailed_name = Intern(qualified_name);
def.qual_name_offset = 0;
def.hover = Intern(hover);
2018-01-17 04:01:47 +00:00
} else {
#if 0
def.detailed_name = param->PrettyPrintCursor(cursor.cx_cursor, false);
#else
int offset = type_name.size();
offset += ConcatTypeAndName(type_name, qualified_name);
def.detailed_name = Intern(type_name);
def.qual_name_offset = offset;
def.short_name_offset += offset;
// Append the textual initializer, bit field, constructor to |hover|.
// Omit |hover| for these types:
// int (*a)(); int (&a)(); int (&&a)(); int a[1]; auto x = ...
// We can take these into consideration after we have better support for
// inside-out syntax.
QualType T = QualType::getFromOpaquePtr(cx_type.data[0]);
while (1) {
const Type* TP = T.getTypePtrOrNull();
if (!TP)
goto skip;
switch (TP->getTypeClass()) {
default:
break;
// case Type::Auto:
// case Type::ConstantArray:
// case Type::IncompleteArray:
// case Type::VariableArray:
// case Type::DependentSizedArray:
// case Type::Vector:
// case Type::Complex:
// goto skip;
case Type::Pointer:
T = cast<PointerType>(TP)->getPointeeType();
continue;
case Type::LValueReference:
case Type::RValueReference:
T = cast<ReferenceType>(TP)->getPointeeType();
continue;
case Type::MemberPointer:
T = cast<MemberPointerType>(TP)->getPointeeType();
continue;
}
break;
}
if (T->getAs<FunctionType>())
goto skip;
{
const FileContents& fc = param->file_contents[db->path];
Position spell_p = cursor.get_spell().end,
extent_p = cursor.get_extent().end;
if (extent_p.line - spell_p.line < kMaxDetailedLines) {
std::optional<int> spell_end = fc.ToOffset(spell_p),
extent_end = fc.ToOffset(extent_p);
if (extent_end && *spell_end < *extent_end)
def.hover =
Intern(std::string(def.detailed_name) +
fc.content.substr(*spell_end, *extent_end - *spell_end));
}
}
skip:;
}
#endif
if (is_first_seen) {
if (IndexType* var_type =
2018-04-15 17:21:26 +00:00
ResolveToDeclarationType(db, cursor, param)) {
// Don't treat enum definition variables as instantiations.
bool is_enum_member = semanticContainer &&
semanticContainer->cursor.kind == CXCursor_EnumDecl;
if (!is_enum_member)
var_type->instances.push_back(var.usr);
def.type = var_type->usr;
}
}
}
void OnIndexReference_Function(IndexFile* db,
Range loc,
ClangCursor parent_cursor,
IndexFunc& called,
Role role) {
switch (GetSymbolKind(parent_cursor.get_kind())) {
case SymbolKind::Func: {
IndexFunc& parent = db->ToFunc(parent_cursor.cx_cursor);
parent.def.callees.push_back(
2018-06-01 04:21:34 +00:00
SymbolRef{{loc, called.usr, SymbolKind::Func, role}});
called.uses.push_back(Use{{loc, parent.usr, SymbolKind::Func, role}});
break;
}
case SymbolKind::Type: {
IndexType& parent = db->ToType(parent_cursor.cx_cursor);
called.uses.push_back(Use{{loc, parent.usr, SymbolKind::Type, role}});
break;
}
default: {
called.uses.push_back(Use{{loc, 0, SymbolKind::File, role}});
break;
}
}
}
} // namespace
2017-06-15 03:12:52 +00:00
// static
const int IndexFile::kMajorVersion = 16;
const int IndexFile::kMinorVersion = 1;
IndexFile::IndexFile(const std::string& path, const std::string& contents)
: path(path), file_contents(contents) {}
2017-02-20 00:56:56 +00:00
IndexFunc& IndexFile::ToFunc(Usr usr) {
auto ret = usr2func.try_emplace(usr);
if (ret.second)
ret.first->second.usr = usr;
return ret.first->second;
2017-02-20 00:56:56 +00:00
}
IndexType& IndexFile::ToType(Usr usr) {
auto ret = usr2type.try_emplace(usr);
if (ret.second)
ret.first->second.usr = usr;
return ret.first->second;
2017-02-20 00:56:56 +00:00
}
IndexVar& IndexFile::ToVar(Usr usr) {
auto ret = usr2var.try_emplace(usr);
if (ret.second)
ret.first->second.usr = usr;
return ret.first->second;
2017-02-17 09:57:44 +00:00
}
std::string IndexFile::ToString() {
return ccls::Serialize(SerializeFormat::Json, *this);
2017-02-17 09:57:44 +00:00
}
2018-05-05 03:40:52 +00:00
void Uniquify(std::vector<Usr>& usrs) {
std::unordered_set<Usr> seen;
size_t n = 0;
2018-05-05 03:40:52 +00:00
for (size_t i = 0; i < usrs.size(); i++)
if (seen.insert(usrs[i]).second)
usrs[n++] = usrs[i];
usrs.resize(n);
}
void Uniquify(std::vector<Use>& uses) {
2018-05-05 03:40:52 +00:00
std::unordered_set<Range> seen;
size_t n = 0;
for (size_t i = 0; i < uses.size(); i++) {
2018-05-05 03:40:52 +00:00
if (seen.insert(uses[i].range).second)
uses[n++] = uses[i];
}
uses.resize(n);
2017-02-24 08:39:25 +00:00
}
2017-02-20 06:40:55 +00:00
void AddUse(IndexFile* db,
std::vector<Use>& uses,
Range range,
ClangCursor parent,
Role role = Role::Reference) {
switch (GetSymbolKind(parent.get_kind())) {
case SymbolKind::Func:
uses.push_back(Use{
{range, db->ToFunc(parent.cx_cursor).usr, SymbolKind::Func, role}});
break;
case SymbolKind::Type:
uses.push_back(Use{
{range, db->ToType(parent.cx_cursor).usr, SymbolKind::Type, role}});
2018-02-18 18:07:13 +00:00
break;
default:
uses.push_back(Use{{range, 0, SymbolKind::File, role}});
break;
}
}
CXCursor fromContainer(const CXIdxContainerInfo* parent) {
return parent ? parent->cursor : clang_getNullCursor();
}
2018-02-22 07:34:32 +00:00
void AddUseSpell(IndexFile* db, std::vector<Use>& uses, ClangCursor cursor) {
AddUse(db, uses, cursor.get_spell(), cursor.get_lexical_parent().cx_cursor);
}
2017-12-01 17:57:03 +00:00
void OnIndexDiagnostic(CXClientData client_data,
CXDiagnosticSet diagnostics,
void* reserved) {
IndexParam* param = static_cast<IndexParam*>(client_data);
for (unsigned i = 0; i < clang_getNumDiagnosticsInSet(diagnostics); ++i) {
CXDiagnostic diagnostic = clang_getDiagnosticInSet(diagnostics, i);
CXSourceLocation diag_loc = clang_getDiagnosticLocation(diagnostic);
2018-01-06 17:28:55 +00:00
// Skip diagnostics in system headers.
// if (clang_Location_isInSystemHeader(diag_loc))
// continue;
// Get db so we can attribute diagnostic to the right indexed file.
CXFile file;
unsigned int line, column;
clang_getSpellingLocation(diag_loc, &file, &line, &column, nullptr);
2018-01-06 17:28:55 +00:00
// Skip empty diagnostic.
2018-01-11 02:43:01 +00:00
if (!line && !column)
continue;
IndexFile* db = ConsumeFile(param, file);
if (!db)
continue;
// Build diagnostic.
2018-03-31 03:16:33 +00:00
std::optional<lsDiagnostic> ls_diagnostic =
BuildAndDisposeDiagnostic(diagnostic, db->path);
if (ls_diagnostic)
db->diagnostics_.push_back(*ls_diagnostic);
}
2017-03-11 02:24:51 +00:00
}
2017-02-20 00:56:56 +00:00
2017-12-01 17:57:03 +00:00
CXIdxClientFile OnIndexIncludedFile(CXClientData client_data,
const CXIdxIncludedFileInfo* file) {
2017-05-21 03:46:15 +00:00
IndexParam* param = static_cast<IndexParam*>(client_data);
// file->hashLoc only has the position of the hash. We don't have the full
// range for the include.
CXSourceLocation hash_loc = clang_indexLoc_getCXSourceLocation(file->hashLoc);
CXFile cx_file;
unsigned int line;
clang_getSpellingLocation(hash_loc, &cx_file, &line, nullptr, nullptr);
line--;
2017-05-21 03:46:15 +00:00
IndexFile* db = ConsumeFile(param, cx_file);
if (!db)
return nullptr;
IndexInclude include;
include.line = line;
include.resolved_path = FileName(file->file);
2018-03-31 20:59:27 +00:00
if (include.resolved_path.size())
db->includes.push_back(include);
2017-05-21 03:46:15 +00:00
2017-02-20 00:56:56 +00:00
return nullptr;
}
2017-02-20 02:00:58 +00:00
struct FindChildOfKindParam {
CXCursorKind target_kind;
2018-03-31 03:16:33 +00:00
std::optional<ClangCursor> result;
2017-02-20 02:00:58 +00:00
FindChildOfKindParam(CXCursorKind target_kind) : target_kind(target_kind) {}
};
ClangCursor::VisitResult FindTypeVisitor(ClangCursor cursor,
ClangCursor parent,
2018-03-31 03:16:33 +00:00
std::optional<ClangCursor>* result) {
2017-02-20 19:08:27 +00:00
switch (cursor.get_kind()) {
2017-03-17 07:58:41 +00:00
case CXCursor_TypeRef:
case CXCursor_TemplateRef:
*result = cursor;
return ClangCursor::VisitResult::Break;
2017-05-21 23:48:21 +00:00
default:
break;
2017-02-20 19:08:27 +00:00
}
return ClangCursor::VisitResult::Recurse;
2017-02-20 19:08:27 +00:00
}
2018-03-31 03:16:33 +00:00
std::optional<ClangCursor> FindType(ClangCursor cursor) {
std::optional<ClangCursor> result;
2017-02-20 19:08:27 +00:00
cursor.VisitChildren(&FindTypeVisitor, &result);
return result;
}
2017-02-20 00:56:56 +00:00
bool IsTypeDefinition(const CXIdxContainerInfo* container) {
if (!container)
return false;
return GetSymbolKind(container->cursor.kind) == SymbolKind::Type;
2017-02-20 00:56:56 +00:00
}
struct VisitDeclForTypeUsageParam {
IndexFile* db;
IndexType* toplevel_type;
int has_processed_any = false;
2018-03-31 03:16:33 +00:00
std::optional<ClangCursor> previous_cursor;
IndexType* initial_type = nullptr;
VisitDeclForTypeUsageParam(IndexFile* db, IndexType* toplevel_type)
: db(db), toplevel_type(toplevel_type) {}
};
void VisitDeclForTypeUsageVisitorHandler(ClangCursor cursor,
2017-03-17 07:58:41 +00:00
VisitDeclForTypeUsageParam* param) {
param->has_processed_any = true;
IndexFile* db = param->db;
// For |A<int> a| where there is a specialization for |A<int>|,
// the |referenced_usr| below resolves to the primary template and
// attributes the use to the primary template instead of the specialization.
2018-01-30 00:27:43 +00:00
// |toplevel_type| is retrieved |clang_getCursorType| which can be a
// specialization. If its name is the same as the primary template's, we
// assume the use should be attributed to the specialization. This heuristic
// fails when a member class bears the same name with its container.
//
// template<class T>
// struct C { struct C {}; };
// C<int>::C a;
//
// We will attribute |::C| to the parent class.
if (param->toplevel_type) {
IndexType& ref_type = *param->toplevel_type;
2018-02-18 18:07:13 +00:00
std::string name = cursor.get_referenced().get_spell_name();
if (name == ref_type.def.Name(false)) {
AddUseSpell(db, ref_type.uses, cursor);
param->toplevel_type = nullptr;
return;
}
}
2018-05-09 05:01:58 +00:00
std::optional<Usr> referenced_usr =
2018-01-30 00:27:43 +00:00
cursor.get_referenced()
.template_specialization_to_template_definition()
2018-05-09 05:01:58 +00:00
.get_opt_usr_hash();
// In STL this may be empty.
if (!referenced_usr)
return;
2018-05-09 05:01:58 +00:00
IndexType& ref_type = db->ToType(*referenced_usr);
2017-03-05 22:49:23 +00:00
if (!param->initial_type)
param->initial_type = &ref_type;
// TODO: Should we even be visiting this if the file is not from the main
// def? Try adding assert on |loc| later.
AddUseSpell(db, ref_type.uses, cursor);
2017-02-20 19:08:27 +00:00
}
ClangCursor::VisitResult VisitDeclForTypeUsageVisitor(
ClangCursor cursor,
ClangCursor parent,
2017-03-17 07:58:41 +00:00
VisitDeclForTypeUsageParam* param) {
switch (cursor.get_kind()) {
2017-03-17 07:58:41 +00:00
case CXCursor_TemplateRef:
case CXCursor_TypeRef:
if (param->previous_cursor) {
VisitDeclForTypeUsageVisitorHandler(param->previous_cursor.value(),
param);
}
2017-03-17 07:58:41 +00:00
param->previous_cursor = cursor;
return ClangCursor::VisitResult::Continue;
// We do not want to recurse for everything, since if we do that we will end
// up visiting method definition bodies/etc. Instead, we only recurse for
2017-03-17 07:58:41 +00:00
// things that can logically appear as part of an inline variable
// initializer,
// ie,
//
// class Foo {
// int x = (Foo)3;
// }
2017-03-17 07:58:41 +00:00
case CXCursor_CallExpr:
case CXCursor_CStyleCastExpr:
case CXCursor_CXXStaticCastExpr:
case CXCursor_CXXReinterpretCastExpr:
return ClangCursor::VisitResult::Recurse;
2017-05-21 23:48:21 +00:00
default:
return ClangCursor::VisitResult::Continue;
}
return ClangCursor::VisitResult::Continue;
}
2017-03-17 07:58:41 +00:00
// Add usages to any seen TypeRef or TemplateRef under the given |decl_cursor|.
2017-04-03 01:34:15 +00:00
// This returns the first seen TypeRef or TemplateRef value, which can be
// useful if trying to figure out ie, what a using statement refers to. If
// trying to generally resolve a cursor to a type, use
// ResolveToDeclarationType, which works in more scenarios.
// If |decl_cursor| is a variable of a template type, clang_getCursorType
// may return a specialized template which is preciser than the primary
// template.
// We use |toplevel_type| to attribute the use to the specialized template
// instead of the primary template.
IndexType* AddDeclTypeUsages(IndexFile* db,
ClangCursor decl_cursor,
IndexType* toplevel_type,
const CXIdxContainerInfo* semantic_container,
const CXIdxContainerInfo* lexical_container) {
//
// The general AST format for definitions follows this pattern:
//
// template<typename A, typename B>
// struct Container;
//
// struct S1;
// struct S2;
//
// Container<Container<S1, S2>, S2> foo;
//
// =>
//
// VarDecl
// TemplateRef Container
// TemplateRef Container
// TypeRef struct S1
// TypeRef struct S2
// TypeRef struct S2
//
2017-03-05 22:49:23 +00:00
//
// Here is another example:
//
// enum A {};
// enum B {};
2017-03-14 04:31:53 +00:00
//
2017-03-05 22:49:23 +00:00
// template<typename T>
// struct Foo {
// struct Inner {};
// };
2017-03-14 04:31:53 +00:00
//
2017-03-05 22:49:23 +00:00
// Foo<A>::Inner a;
// Foo<B> b;
2017-03-14 04:31:53 +00:00
//
2017-03-05 22:49:23 +00:00
// =>
//
// EnumDecl A
// EnumDecl B
// ClassTemplate Foo
// TemplateTypeParameter T
// StructDecl Inner
// VarDecl a
// TemplateRef Foo
// TypeRef enum A
// TypeRef struct Foo<enum A>::Inner
// CallExpr Inner
// VarDecl b
// TemplateRef Foo
// TypeRef enum B
// CallExpr Foo
//
//
// Determining the actual type of the variable/declaration from just the
// children is tricky. Doing so would require looking up the template
// definition associated with a TemplateRef, figuring out how many children
// it has, and then skipping that many TypeRef values. This also has to work
// with the example below (skipping the last TypeRef). As a result, we
// determine variable types using |ResolveToDeclarationType|.
//
//
// We skip the last type reference for methods/variables which are defined
// out-of-line w.r.t. the parent type.
//
// S1* Foo::foo() {}
2017-02-22 01:06:43 +00:00
//
// The above example looks like this in the AST:
//
// CXXMethod foo
// TypeRef struct S1
// TypeRef class Foo
// CompoundStmt
// ...
//
// The second TypeRef is an uninteresting usage.
bool process_last_type_ref = true;
2017-03-17 07:58:41 +00:00
if (IsTypeDefinition(semantic_container) &&
!IsTypeDefinition(lexical_container)) {
//
2017-03-17 07:58:41 +00:00
// In some code, such as the following example, we receive a cursor which is
// not
// a definition and is not associated with a definition due to an error
// condition.
// In this case, it is the Foo::Foo constructor.
//
// struct Foo {};
//
// template<class T>
// Foo::Foo() {}
//
if (!decl_cursor.is_definition()) {
ClangCursor def = decl_cursor.get_definition();
if (def.get_kind() != CXCursor_FirstInvalid)
decl_cursor = def;
}
process_last_type_ref = false;
}
2017-02-20 19:08:27 +00:00
VisitDeclForTypeUsageParam param(db, toplevel_type);
decl_cursor.VisitChildren(&VisitDeclForTypeUsageVisitor, &param);
// VisitDeclForTypeUsageVisitor guarantees that if there are multiple TypeRef
// children, the first one will always be visited.
if (param.previous_cursor && process_last_type_ref) {
VisitDeclForTypeUsageVisitorHandler(param.previous_cursor.value(), &param);
2017-03-17 07:58:41 +00:00
} else {
// If we are not processing the last type ref, it *must* be a TypeRef or
// TemplateRef.
2017-03-05 22:49:23 +00:00
//
2017-03-17 07:58:41 +00:00
// We will not visit every child if the is_interseting is false, so
// previous_cursor
2017-03-05 22:49:23 +00:00
// may not point to the last TemplateRef.
assert(param.previous_cursor.has_value() == false ||
2017-03-17 07:58:41 +00:00
(param.previous_cursor.value().get_kind() == CXCursor_TypeRef ||
param.previous_cursor.value().get_kind() == CXCursor_TemplateRef));
}
2017-02-20 19:08:27 +00:00
if (param.initial_type)
return param.initial_type;
CXType cx_under = clang_getTypedefDeclUnderlyingType(decl_cursor.cx_cursor);
if (cx_under.kind == CXType_Invalid)
return nullptr;
return &db->ToType(ClangType(cx_under).strip_qualifiers().get_usr_hash());
}
2017-02-20 19:08:27 +00:00
2017-03-17 07:58:41 +00:00
// Various versions of LLVM (ie, 4.0) will not visit inline variable references
// for template arguments.
ClangCursor::VisitResult AddDeclInitializerUsagesVisitor(ClangCursor cursor,
ClangCursor parent,
IndexFile* db) {
2017-03-14 04:31:53 +00:00
/*
2017-03-17 07:58:41 +00:00
We need to index the |DeclRefExpr| below (ie, |var| inside of
Foo<int>::var).
2017-03-14 04:31:53 +00:00
template<typename T>
struct Foo {
static constexpr int var = 3;
};
int a = Foo<int>::var;
=>
VarDecl a
UnexposedExpr var
DeclRefExpr var
TemplateRef Foo
*/
switch (cursor.get_kind()) {
2017-05-21 23:48:21 +00:00
case CXCursor_DeclRefExpr: {
2017-03-17 07:58:41 +00:00
if (cursor.get_referenced().get_kind() != CXCursor_VarDecl)
break;
// TODO: when we resolve the template type to the definition, we get a
2018-01-13 08:10:39 +00:00
// different Usr.
2017-03-17 07:58:41 +00:00
// ClangCursor ref =
// cursor.get_referenced().template_specialization_to_template_definition().get_type().strip_qualifiers().get_usr_hash();
2017-03-17 07:58:41 +00:00
// std::string ref_usr =
// cursor.get_referenced().template_specialization_to_template_definition().get_type().strip_qualifiers().get_usr_hash();
auto ref_usr = cursor.get_referenced()
.template_specialization_to_template_definition()
2018-05-09 05:01:58 +00:00
.get_opt_usr_hash();
if (!ref_usr)
2017-03-17 07:58:41 +00:00
break;
2018-05-09 05:01:58 +00:00
IndexVar& ref_var = db->ToVar(*ref_usr);
AddUseSpell(db, ref_var.uses, cursor);
2017-03-14 04:31:53 +00:00
break;
2017-05-21 23:48:21 +00:00
}
default:
break;
2017-03-14 04:31:53 +00:00
}
return ClangCursor::VisitResult::Recurse;
2017-03-14 04:31:53 +00:00
}
ClangCursor::VisitResult VisitMacroDefinitionAndExpansions(ClangCursor cursor,
ClangCursor parent,
IndexParam* param) {
switch (cursor.get_kind()) {
case CXCursor_MacroDefinition:
2017-05-21 23:48:21 +00:00
case CXCursor_MacroExpansion: {
// Resolve location, find IndexFile instance.
2017-09-22 01:14:57 +00:00
CXSourceRange cx_source_range =
clang_Cursor_getSpellingNameRange(cursor.cx_cursor, 0, 0);
CXFile file;
Range decl_loc_spelling = ResolveCXSourceRange(cx_source_range, &file);
IndexFile* db = ConsumeFile(param, file);
if (!db)
break;
// TODO: Considering checking clang_Cursor_isMacroFunctionLike, but the
// only real difference will be that we show 'callers' instead of 'refs'
// (especially since macros cannot have overrides)
2018-01-13 08:10:39 +00:00
Usr decl_usr;
if (cursor.get_kind() == CXCursor_MacroDefinition)
decl_usr = cursor.get_usr_hash();
else
decl_usr = cursor.get_referenced().get_usr_hash();
IndexVar& var_def = db->ToVar(decl_usr);
if (cursor.get_kind() == CXCursor_MacroDefinition) {
CXSourceRange cx_extent = clang_getCursorExtent(cursor.cx_cursor);
var_def.def.detailed_name = Intern(cursor.get_display_name());
var_def.def.qual_name_offset = 0;
var_def.def.short_name_offset = 0;
var_def.def.short_name_size =
int16_t(strlen(var_def.def.detailed_name));
var_def.def.hover =
Intern("#define " +
GetDocumentContentInRange(param->tu->cx_tu, cx_extent));
var_def.def.kind = lsSymbolKind::Macro;
2018-04-04 06:05:41 +00:00
if (g_config->index.comments)
var_def.def.comments = Intern(cursor.get_comments());
var_def.def.spell =
2018-02-18 18:07:13 +00:00
SetUse(db, decl_loc_spelling, parent, Role::Definition);
var_def.def.extent = SetUse(
2018-02-18 18:07:13 +00:00
db, ResolveCXSourceRange(cx_extent, nullptr), parent, Role::None);
} else
AddUse(db, var_def.uses, decl_loc_spelling, parent);
2017-05-21 23:48:21 +00:00
break;
}
default:
break;
}
return ClangCursor::VisitResult::Continue;
}
namespace {
// TODO Move to another file and use clang C++ API
struct TemplateVisitorData {
IndexFile* db;
IndexParam* param;
ClangCursor container;
};
ClangCursor::VisitResult TemplateVisitor(ClangCursor cursor,
ClangCursor parent,
TemplateVisitorData* data) {
IndexFile* db = data->db;
IndexParam* param = data->param;
switch (cursor.get_kind()) {
default:
2017-12-24 21:28:53 +00:00
break;
case CXCursor_DeclRefExpr: {
ClangCursor ref_cursor = clang_getCursorReferenced(cursor.cx_cursor);
if (ref_cursor.get_kind() == CXCursor_NonTypeTemplateParameter) {
IndexVar& ref_var = db->ToVar(ref_cursor);
if (!ref_var.def.detailed_name[0]) {
2018-02-18 18:07:13 +00:00
ClangCursor sem_parent = ref_cursor.get_semantic_parent();
ClangCursor lex_parent = ref_cursor.get_lexical_parent();
ref_var.def.spell =
2018-02-22 07:34:32 +00:00
SetUse(db, ref_cursor.get_spell(), sem_parent, Role::Definition);
ref_var.def.extent =
2018-02-18 18:07:13 +00:00
SetUse(db, ref_cursor.get_extent(), lex_parent, Role::None);
ref_var.def.kind = lsSymbolKind::TypeParameter;
2018-02-18 18:07:13 +00:00
SetVarDetail(ref_var, ref_cursor.get_spell_name(), ref_cursor,
nullptr, true, db, param);
ClangType ref_type_c = clang_getCursorType(ref_cursor.cx_cursor);
// TODO optimize
if (ref_type_c.get_usr().size()) {
IndexType& ref_type = db->ToType(ref_type_c.get_usr_hash());
// The cursor extent includes `type name`, not just `name`. There
// seems no way to extract the spelling range of `type` and we do
// not want to do subtraction here.
2018-03-31 03:16:33 +00:00
// See https://github.com/cquery-project/cquery/issues/252
AddUse(db, ref_type.uses, ref_cursor.get_extent(),
ref_cursor.get_lexical_parent());
2018-01-07 09:19:57 +00:00
}
}
AddUseSpell(db, ref_var.uses, cursor);
}
break;
}
case CXCursor_OverloadedDeclRef: {
unsigned num_overloaded = clang_getNumOverloadedDecls(cursor.cx_cursor);
for (unsigned i = 0; i != num_overloaded; i++) {
ClangCursor overloaded = clang_getOverloadedDecl(cursor.cx_cursor, i);
switch (overloaded.get_kind()) {
default:
break;
case CXCursor_FunctionDecl:
case CXCursor_FunctionTemplate: {
IndexFunc& called = db->ToFunc(overloaded.get_usr_hash());
2018-02-22 07:34:32 +00:00
OnIndexReference_Function(db, cursor.get_spell(), data->container,
called, Role::Call);
break;
}
}
}
2017-12-24 21:28:53 +00:00
break;
}
case CXCursor_TemplateRef: {
ClangCursor ref_cursor = clang_getCursorReferenced(cursor.cx_cursor);
if (ref_cursor.get_kind() == CXCursor_TemplateTemplateParameter) {
IndexType& ref_type = db->ToType(ref_cursor);
// TODO It seems difficult to get references to template template
// parameters.
// CXCursor_TemplateTemplateParameter can be visited by visiting
// CXCursor_TranslationUnit, but not (confirm this) by visiting
// {Class,Function}Template. Thus we need to initialize it here.
if (!ref_type.def.detailed_name[0]) {
2018-02-18 18:07:13 +00:00
ClangCursor sem_parent = ref_cursor.get_semantic_parent();
ClangCursor lex_parent = ref_cursor.get_lexical_parent();
ref_type.def.spell =
2018-02-22 07:34:32 +00:00
SetUse(db, ref_cursor.get_spell(), sem_parent, Role::Definition);
ref_type.def.extent =
2018-02-18 18:07:13 +00:00
SetUse(db, ref_cursor.get_extent(), lex_parent, Role::None);
2018-02-22 07:34:32 +00:00
#if 0 && CINDEX_HAVE_PRETTY
ref_type->def.detailed_name = param->PrettyPrintCursor(ref_cursor.cx_cursor);
#else
ref_type.def.detailed_name = Intern(ref_cursor.get_spell_name());
#endif
ref_type.def.short_name_offset = 0;
ref_type.def.short_name_size =
int16_t(strlen(ref_type.def.detailed_name));
ref_type.def.kind = lsSymbolKind::TypeParameter;
}
AddUseSpell(db, ref_type.uses, cursor);
}
break;
}
case CXCursor_TypeRef: {
ClangCursor ref_cursor = clang_getCursorReferenced(cursor.cx_cursor);
if (ref_cursor.get_kind() == CXCursor_TemplateTypeParameter) {
IndexType& ref_type = db->ToType(ref_cursor);
2017-12-28 17:22:26 +00:00
// TODO It seems difficult to get a FunctionTemplate's template
// parameters.
// CXCursor_TemplateTypeParameter can be visited by visiting
// CXCursor_TranslationUnit, but not (confirm this) by visiting
// {Class,Function}Template. Thus we need to initialize it here.
if (!ref_type.def.detailed_name[0]) {
2018-02-18 18:07:13 +00:00
ClangCursor sem_parent = ref_cursor.get_semantic_parent();
ClangCursor lex_parent = ref_cursor.get_lexical_parent();
ref_type.def.spell =
2018-02-22 07:34:32 +00:00
SetUse(db, ref_cursor.get_spell(), sem_parent, Role::Definition);
ref_type.def.extent =
2018-02-18 18:07:13 +00:00
SetUse(db, ref_cursor.get_extent(), lex_parent, Role::None);
2018-02-22 07:34:32 +00:00
#if 0 && CINDEX_HAVE_PRETTY
2018-02-21 01:50:48 +00:00
// template<class T> void f(T t){} // weird, the name is empty
ref_type->def.detailed_name = param->PrettyPrintCursor(ref_cursor.cx_cursor);
#else
ref_type.def.detailed_name = Intern(ref_cursor.get_spell_name());
#endif
ref_type.def.short_name_offset = 0;
ref_type.def.short_name_size =
int16_t(strlen(ref_type.def.detailed_name));
ref_type.def.kind = lsSymbolKind::TypeParameter;
}
AddUseSpell(db, ref_type.uses, cursor);
}
break;
}
}
return ClangCursor::VisitResult::Recurse;
}
} // namespace
std::tuple<std::string, int16_t, int16_t> NamespaceHelper::QualifiedName(
2018-03-31 16:25:58 +00:00
const CXIdxContainerInfo* container,
std::string_view unqualified_name) {
if (!container)
return {std::string(unqualified_name), 0, 0};
// Anonymous namespaces are not processed by indexDeclaration. We trace
// nested namespaces bottom-up through clang_getCursorSemanticParent until
// one that we know its qualified name. Then do another trace top-down and
// put their names into a map of USR -> qualified_name.
2018-01-26 06:20:28 +00:00
ClangCursor cursor(container->cursor);
std::vector<ClangCursor> namespaces;
std::string qualifier;
while (cursor.get_kind() != CXCursor_TranslationUnit &&
2018-03-02 18:18:01 +00:00
GetSymbolKind(cursor.get_kind()) == SymbolKind::Type) {
2018-05-09 05:01:58 +00:00
auto it = usr2qualified_name.find(cursor.get_usr_hash());
if (it != usr2qualified_name.end()) {
qualifier = it->second;
break;
}
namespaces.push_back(cursor);
cursor = clang_getCursorSemanticParent(cursor.cx_cursor);
}
for (size_t i = namespaces.size(); i > 0;) {
i--;
2018-02-18 18:07:13 +00:00
std::string name = namespaces[i].get_spell_name();
// Empty name indicates unnamed namespace, anonymous struct, anonymous
// union, ...
if (name.size())
qualifier += name;
else
qualifier += GetAnonName(namespaces[i].get_kind());
qualifier += "::";
2018-05-09 05:01:58 +00:00
usr2qualified_name[namespaces[i].get_usr_hash()] = qualifier;
}
int16_t pos = qualifier.size();
2018-03-31 16:25:58 +00:00
qualifier.append(unqualified_name);
return {qualifier, pos, int16_t(unqualified_name.size())};
}
2017-12-01 17:57:03 +00:00
void OnIndexDeclaration(CXClientData client_data, const CXIdxDeclInfo* decl) {
IndexParam* param = static_cast<IndexParam*>(client_data);
// Track all constructor declarations, as we may need to use it to manually
// associate std::make_unique and the like as constructor invocations.
if (decl->entityInfo->kind == CXIdxEntity_CXXConstructor) {
param->ctors.NotifyConstructor(decl->cursor);
}
2017-04-08 22:54:36 +00:00
CXFile file;
2017-09-22 01:14:57 +00:00
clang_getSpellingLocation(clang_indexLoc_getCXSourceLocation(decl->loc),
&file, nullptr, nullptr, nullptr);
IndexFile* db = ConsumeFile(param, file);
2017-04-08 22:54:36 +00:00
if (!db)
return;
// The language of this declaration
LanguageId decl_lang = [&decl]() {
2017-12-01 17:50:39 +00:00
switch (clang_getCursorLanguage(decl->cursor)) {
case CXLanguage_C:
return LanguageId::C;
case CXLanguage_CPlusPlus:
return LanguageId::Cpp;
case CXLanguage_ObjC:
return LanguageId::ObjC;
default:
return LanguageId::Unknown;
2017-12-01 17:50:39 +00:00
};
}();
// Only update the file language if the new language is "greater" than the old
2017-11-30 22:09:29 +00:00
if (decl_lang > db->language) {
db->language = decl_lang;
}
ClangCursor sem_parent(fromContainer(decl->semanticContainer));
ClangCursor lex_parent(fromContainer(decl->lexicalContainer));
ClangCursor cursor = decl->cursor;
2017-02-20 00:56:56 +00:00
switch (decl->entityInfo->kind) {
case CXIdxEntity_Unexposed:
LOG_S(INFO) << "CXIdxEntity_Unexposed " << cursor.get_spell_name();
break;
2018-01-24 08:19:42 +00:00
case CXIdxEntity_CXXNamespace: {
Range spell = cursor.get_spell();
IndexType& ns = db->ToType(HashUsr(decl->entityInfo->USR));
ns.def.kind = GetSymbolKind(decl->entityInfo->kind);
if (!ns.def.detailed_name[0]) {
2018-02-22 07:34:32 +00:00
SetTypeName(ns, cursor, decl->semanticContainer, decl->entityInfo->name,
param);
ns.def.spell = SetUse(db, spell, sem_parent, Role::Definition);
ns.def.extent =
SetUse(db, cursor.get_extent(), lex_parent, Role::None);
2018-01-24 08:19:42 +00:00
if (decl->semanticContainer) {
IndexType& parent = db->ToType(decl->semanticContainer->cursor);
parent.derived.push_back(ns.usr);
ns.def.bases.push_back(parent.usr);
2018-01-24 08:19:42 +00:00
}
}
AddUse(db, ns.uses, spell, lex_parent);
break;
2018-01-24 08:19:42 +00:00
}
case CXIdxEntity_CXXNamespaceAlias:
assert(false && "CXXNamespaceAlias");
break;
2017-12-18 20:06:13 +00:00
case CXIdxEntity_ObjCProperty:
case CXIdxEntity_ObjCIvar:
2017-03-17 07:58:41 +00:00
case CXIdxEntity_EnumConstant:
case CXIdxEntity_Field:
case CXIdxEntity_Variable:
case CXIdxEntity_CXXStaticVariable: {
2018-02-18 18:07:13 +00:00
Range spell = cursor.get_spell();
2017-03-14 04:31:53 +00:00
2017-03-17 07:58:41 +00:00
// Do not index implicit template instantiations.
2018-02-18 18:07:13 +00:00
if (cursor != cursor.template_specialization_to_template_definition())
2017-03-17 07:58:41 +00:00
break;
2017-02-20 00:56:56 +00:00
IndexVar& var = db->ToVar(HashUsr(decl->entityInfo->USR));
2017-02-20 00:56:56 +00:00
2017-03-17 07:58:41 +00:00
// TODO: Eventually run with this if. Right now I want to iron out bugs
// this may shadow.
// TODO: Verify this gets called multiple times
// if (!decl->isRedeclaration) {
SetVarDetail(var, std::string(decl->entityInfo->name), decl->cursor,
decl->semanticContainer, !decl->isRedeclaration, db, param);
var.def.kind = GetSymbolKind(decl->entityInfo->kind);
if (var.def.kind == lsSymbolKind::Variable &&
decl->cursor.kind == CXCursor_ParmDecl)
var.def.kind = lsSymbolKind::Parameter;
//}
if (!decl->isDefinition)
var.declarations.push_back(
SetUse(db, spell, lex_parent, Role::Declaration));
// For `static const`, a definition at namespace scope is not required
// unless odr-used.
if (decl->isDefinition ||
(decl->entityInfo->kind == CXIdxEntity_CXXStaticVariable &&
clang_isConstQualifiedType(clang_getCursorType(decl->cursor)))) {
var.def.spell = SetUse(db, spell, sem_parent, Role::Definition);
var.def.extent =
2018-02-18 18:07:13 +00:00
SetUse(db, cursor.get_extent(), lex_parent, Role::None);
2017-04-05 08:06:18 +00:00
}
2017-03-17 07:58:41 +00:00
2018-02-18 18:07:13 +00:00
cursor.VisitChildren(&AddDeclInitializerUsagesVisitor, db);
2017-03-17 07:58:41 +00:00
// Declaring variable type information. Note that we do not insert an
// interesting reference for parameter declarations - that is handled when
// the function declaration is encountered since we won't receive ParmDecl
// declarations for unnamed parameters.
// TODO: See if we can remove this function call.
AddDeclTypeUsages(
db, cursor,
var.def.type ? &db->ToType(var.def.type) : nullptr,
decl->semanticContainer, decl->lexicalContainer);
2017-03-17 07:58:41 +00:00
2017-04-03 01:34:15 +00:00
// We don't need to assign declaring type multiple times if this variable
// has already been seen.
if (decl->isDefinition && decl->semanticContainer) {
switch (GetSymbolKind(decl->semanticContainer->cursor.kind)) {
case SymbolKind::Func: {
db->ToFunc(decl->semanticContainer->cursor)
.def.vars.push_back(var.usr);
break;
}
case SymbolKind::Type: {
CXCursor parent = decl->semanticContainer->cursor;
long offset = clang_Cursor_getOffsetOfField(cursor.cx_cursor);
while (parent.kind != CXCursor_EnumDecl) {
IndexType& type = db->ToType(parent);
type.def.vars.emplace_back(var.usr, offset);
if (!clang_Cursor_isAnonymous(parent)) break;
parent = clang_getCursorSemanticParent(parent);
offset = -1;
if (GetSymbolKind(parent.kind) != SymbolKind::Type) break;
}
break;
}
default:
break;
}
2017-02-21 05:16:45 +00:00
}
2017-03-17 07:58:41 +00:00
break;
}
2017-02-21 05:16:45 +00:00
2017-12-15 20:14:57 +00:00
case CXIdxEntity_ObjCInstanceMethod:
case CXIdxEntity_ObjCClassMethod:
2017-03-17 07:58:41 +00:00
case CXIdxEntity_Function:
case CXIdxEntity_CXXConstructor:
case CXIdxEntity_CXXDestructor:
case CXIdxEntity_CXXInstanceMethod:
case CXIdxEntity_CXXStaticMethod:
case CXIdxEntity_CXXConversionFunction: {
Range spell = cursor.get_spell();
Range extent = cursor.get_extent();
2017-04-03 01:34:15 +00:00
ClangCursor decl_cursor_resolved =
cursor.template_specialization_to_template_definition();
bool is_template_specialization = cursor != decl_cursor_resolved;
2017-03-17 07:58:41 +00:00
IndexFunc& func = db->ToFunc(decl_cursor_resolved);
2018-04-04 06:05:41 +00:00
if (g_config->index.comments)
func.def.comments = Intern(cursor.get_comments());
func.def.kind = GetSymbolKind(decl->entityInfo->kind);
func.def.storage =
GetStorageC(clang_Cursor_getStorageClass(decl->cursor));
2017-03-17 07:58:41 +00:00
// We don't actually need to know the return type, but we need to mark it
// as an interesting usage.
AddDeclTypeUsages(db, cursor, nullptr, decl->semanticContainer,
2017-09-22 01:14:57 +00:00
decl->lexicalContainer);
2017-03-17 07:58:41 +00:00
2017-05-27 19:56:39 +00:00
// Add definition or declaration. This is a bit tricky because we treat
// template specializations as declarations, even though they are
// technically definitions.
bool is_def = decl->isDefinition;
if (!is_def) {
auto* D = static_cast<const Decl*>(decl->cursor.data[0]);
auto* Method = dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction());
is_def = Method && (Method->isDefaulted() || Method->isPure());
}
if (is_def && !is_template_specialization) {
func.def.spell = SetUse(db, spell, sem_parent, Role::Definition);
func.def.extent = SetUse(db, extent, lex_parent, Role::None);
2017-09-22 01:14:57 +00:00
} else {
func.declarations.push_back(
SetUse(db, spell, lex_parent, Role::Declaration));
2017-04-05 08:06:18 +00:00
}
2017-03-17 07:58:41 +00:00
2017-05-27 19:56:39 +00:00
// Emit definition data for the function. We do this even if it isn't a
// definition because there can be, for example, interfaces, or a class
// declaration that doesn't have a definition yet. If we never end up
// indexing the definition, then there will not be any (ie) outline
// information.
if (!is_template_specialization) {
std::string detailed;
std::tie(detailed, func.def.qual_name_offset,
func.def.short_name_offset, func.def.short_name_size) =
param->PrettyPrintCursor(decl->cursor, decl->entityInfo->name);
func.def.detailed_name = Intern(detailed);
// CXCursor_OverloadedDeclRef in templates are not processed by
// OnIndexReference, thus we use TemplateVisitor to collect function
// references.
if (decl->entityInfo->templateKind == CXIdxEntity_Template) {
TemplateVisitorData data;
data.db = db;
2018-01-17 04:30:45 +00:00
data.param = param;
data.container = cursor;
cursor.VisitChildren(&TemplateVisitor, &data);
}
2017-03-17 07:58:41 +00:00
// Add function usage information. We only want to do it once per
// definition/declaration. Do it on definition since there should only
// ever be one of those in the entire program.
2017-03-17 07:58:41 +00:00
if (IsTypeDefinition(decl->semanticContainer)) {
IndexType& declaring_type =
db->ToType(decl->semanticContainer->cursor);
func.def.declaring_type = declaring_type.usr;
2017-03-17 07:58:41 +00:00
// Mark a type reference at the ctor/dtor location.
if (decl->entityInfo->kind == CXIdxEntity_CXXConstructor)
AddUse(db, declaring_type.uses, spell,
fromContainer(decl->lexicalContainer));
2017-05-27 19:56:39 +00:00
// Add function to declaring type.
declaring_type.def.funcs.push_back(func.usr);
2017-03-17 07:58:41 +00:00
}
2017-02-20 07:06:38 +00:00
// Process inheritance.
if (clang_CXXMethod_isVirtual(decl->cursor)) {
CXCursor* overridden;
unsigned int num_overridden;
clang_getOverriddenCursors(decl->cursor, &overridden,
2017-09-22 01:14:57 +00:00
&num_overridden);
for (unsigned i = 0; i < num_overridden; ++i) {
ClangCursor parent =
ClangCursor(overridden[i])
.template_specialization_to_template_definition();
IndexFunc& parent_def = db->ToFunc(parent);
func.def.bases.push_back(parent_def.usr);
parent_def.derived.push_back(func.usr);
}
2017-02-20 07:06:38 +00:00
clang_disposeOverriddenCursors(overridden);
}
2017-02-20 07:06:38 +00:00
}
2017-03-17 07:58:41 +00:00
break;
}
2017-02-20 02:35:56 +00:00
2017-03-17 07:58:41 +00:00
case CXIdxEntity_Typedef:
case CXIdxEntity_CXXTypeAlias: {
IndexType& type = db->ToType(HashUsr(decl->entityInfo->USR));
CXType Type = clang_getCursorType(decl->entityInfo->cursor);
CXType CanonType = clang_getCanonicalType(Type);;
if (clang_equalTypes(Type, CanonType) == 0) {
Usr type_usr = ClangType(CanonType).get_usr_hash();
if (db->usr2type.count(type_usr)) {
type.def.alias_of = type_usr;
} else {
// Note we want to fetch the first TypeRef. Running
// ResolveCursorType(decl->cursor) would return
// the type of the typedef/using, not the type of the referenced type.
IndexType* alias_of = AddDeclTypeUsages(
db, cursor, nullptr, decl->semanticContainer, decl->lexicalContainer);
if (alias_of)
type.def.alias_of = alias_of->usr;
}
}
Range spell = cursor.get_spell();
Range extent = cursor.get_extent();
type.def.spell = SetUse(db, spell, sem_parent, Role::Definition);
type.def.extent = SetUse(db, extent, lex_parent, Role::None);
SetTypeName(type, cursor, decl->semanticContainer,
decl->entityInfo->name, param);
type.def.kind = GetSymbolKind(decl->entityInfo->kind);
2018-04-04 06:05:41 +00:00
if (g_config->index.comments)
type.def.comments = Intern(cursor.get_comments());
2017-12-23 16:01:43 +00:00
// For Typedef/CXXTypeAlias spanning a few lines, display the declaration
// line, with spelling name replaced with qualified name.
if (extent.end.line - extent.start.line < kMaxDetailedLines) {
FileContents& fc = param->file_contents[db->path];
2018-03-31 03:16:33 +00:00
std::optional<int> extent_start = fc.ToOffset(extent.start),
2017-12-19 07:05:12 +00:00
spell_start = fc.ToOffset(spell.start),
spell_end = fc.ToOffset(spell.end),
extent_end = fc.ToOffset(extent.end);
if (extent_start && spell_start && spell_end && extent_end) {
type.def.hover = Intern(
fc.content.substr(*extent_start, *spell_start - *extent_start) +
type.def.detailed_name +
fc.content.substr(*spell_end, *extent_end - *spell_end));
}
}
2017-03-17 07:58:41 +00:00
AddUse(db, type.uses, spell, fromContainer(decl->lexicalContainer));
2017-03-17 07:58:41 +00:00
break;
2017-02-21 06:11:47 +00:00
}
2017-12-15 20:14:57 +00:00
case CXIdxEntity_ObjCProtocol:
case CXIdxEntity_ObjCCategory:
case CXIdxEntity_ObjCClass:
2017-03-17 07:58:41 +00:00
case CXIdxEntity_Enum:
case CXIdxEntity_Union:
case CXIdxEntity_Struct:
case CXIdxEntity_CXXInterface:
2017-03-17 07:58:41 +00:00
case CXIdxEntity_CXXClass: {
2018-03-02 18:18:01 +00:00
Range spell = cursor.get_spell();
2017-04-03 01:34:15 +00:00
IndexType& type = db->ToType(HashUsr(decl->entityInfo->USR));
2017-03-17 07:58:41 +00:00
2018-03-20 02:51:42 +00:00
SetTypeName(type, cursor, decl->semanticContainer, decl->entityInfo->name,
param);
type.def.kind = GetSymbolKind(decl->entityInfo->kind);
2018-04-04 06:05:41 +00:00
if (g_config->index.comments)
type.def.comments = Intern(cursor.get_comments());
2017-03-17 07:58:41 +00:00
if (decl->isDefinition) {
type.def.spell = SetUse(db, spell, sem_parent, Role::Definition);
type.def.extent =
2018-03-02 18:18:01 +00:00
SetUse(db, cursor.get_extent(), lex_parent, Role::None);
2018-03-02 18:18:01 +00:00
if (cursor.get_kind() == CXCursor_EnumDecl) {
ClangType enum_type = clang_getEnumDeclIntegerType(decl->cursor);
if (!enum_type.is_builtin()) {
IndexType& int_type = db->ToType(enum_type.get_usr_hash());
AddUse(db, int_type.uses, spell,
2018-02-22 07:34:32 +00:00
fromContainer(decl->lexicalContainer));
}
}
2018-01-29 01:30:41 +00:00
} else
AddUse(db, type.declarations, spell,
fromContainer(decl->lexicalContainer), Role::Declaration);
2017-03-17 07:58:41 +00:00
2018-01-29 01:30:41 +00:00
switch (decl->entityInfo->templateKind) {
2018-01-30 00:27:43 +00:00
default:
break;
case CXIdxEntity_TemplateSpecialization:
case CXIdxEntity_TemplatePartialSpecialization: {
// TODO Use a different dimension
ClangCursor origin_cursor =
2018-03-02 18:18:01 +00:00
cursor.template_specialization_to_template_definition();
IndexType& origin = db->ToType(origin_cursor);
2018-01-30 00:27:43 +00:00
// template<class T> class function; // not visited by
// OnIndexDeclaration template<> class function<int> {}; // current
// cursor
if (!origin.def.detailed_name[0]) {
2018-01-30 00:27:43 +00:00
SetTypeName(origin, origin_cursor, nullptr,
&type.def.Name(false)[0], param);
origin.def.kind = type.def.kind;
2018-01-30 00:27:43 +00:00
}
// TODO The name may be assigned in |ResolveToDeclarationType| but
2018-03-31 03:16:33 +00:00
// |spell| is std::nullopt.
CXFile origin_file;
2018-02-18 18:07:13 +00:00
Range origin_spell = origin_cursor.get_spell(&origin_file);
if (!origin.def.spell && file == origin_file) {
2018-02-18 18:07:13 +00:00
ClangCursor origin_sem = origin_cursor.get_semantic_parent();
ClangCursor origin_lex = origin_cursor.get_lexical_parent();
origin.def.spell =
2018-02-18 18:07:13 +00:00
SetUse(db, origin_spell, origin_sem, Role::Definition);
origin.def.extent =
2018-02-18 18:07:13 +00:00
SetUse(db, origin_cursor.get_extent(), origin_lex, Role::None);
2018-01-30 00:27:43 +00:00
}
origin.derived.push_back(type.usr);
type.def.bases.push_back(origin.usr);
[[fallthrough]];
}
2018-01-30 00:27:43 +00:00
case CXIdxEntity_Template: {
TemplateVisitorData data;
data.db = db;
2018-03-02 18:18:01 +00:00
data.container = cursor;
2018-01-30 00:27:43 +00:00
data.param = param;
2018-03-02 18:18:01 +00:00
cursor.VisitChildren(&TemplateVisitor, &data);
2018-01-30 00:27:43 +00:00
break;
2018-01-29 01:30:41 +00:00
}
}
2017-03-17 07:58:41 +00:00
// Add type-level inheritance information.
CXIdxCXXClassDeclInfo const* class_info =
clang_index_getCXXClassDeclInfo(decl);
if (class_info) {
for (unsigned int i = 0; i < class_info->numBases; ++i) {
const CXIdxBaseClassInfo* base_class = class_info->bases[i];
AddDeclTypeUsages(db, base_class->cursor, nullptr,
decl->semanticContainer, decl->lexicalContainer);
IndexType* parent_type =
ResolveToDeclarationType(db, base_class->cursor, param);
if (parent_type) {
parent_type->derived.push_back(type.usr);
type.def.bases.push_back(parent_type->usr);
2017-03-17 07:58:41 +00:00
}
2017-02-21 05:32:40 +00:00
}
}
2017-03-17 07:58:41 +00:00
break;
2017-02-20 00:56:56 +00:00
}
}
}
// Type-dependent member access expressions do not have accurate spelling
// ranges.
//
// Not type dependent
// C<int> f; f.x // .x produces a MemberRefExpr which has a spelling range
// of `x`.
//
// Type dependent
// C<T> e; e.x // .x produces a MemberRefExpr which has a spelling range
// of `e` (weird) and an empty spelling name.
//
// To attribute the use of `x` in `e.x`, we use cursor extent `e.x`
// minus cursor spelling `e` minus the period.
void CheckTypeDependentMemberRefExpr(Range* spell,
const ClangCursor& cursor,
IndexParam* param,
const IndexFile* db) {
if (cursor.get_kind() == CXCursor_MemberRefExpr &&
2018-02-18 18:07:13 +00:00
cursor.get_spell_name().empty()) {
*spell = cursor.get_extent().RemovePrefix(spell->end);
const FileContents& fc = param->file_contents[db->path];
2018-03-31 03:16:33 +00:00
std::optional<int> maybe_period = fc.ToOffset(spell->start);
if (maybe_period) {
int i = *maybe_period;
if (fc.content[i] == '.')
spell->start.column++;
// -> is likely unexposed.
}
}
}
2017-12-01 17:57:03 +00:00
void OnIndexReference(CXClientData client_data, const CXIdxEntityRefInfo* ref) {
2017-04-08 22:54:36 +00:00
// TODO: Use clang_getFileUniqueID
CXFile file;
2017-09-22 01:14:57 +00:00
clang_getSpellingLocation(clang_indexLoc_getCXSourceLocation(ref->loc), &file,
nullptr, nullptr, nullptr);
2017-04-08 18:36:32 +00:00
IndexParam* param = static_cast<IndexParam*>(client_data);
IndexFile* db = ConsumeFile(param, file);
2017-04-08 22:54:36 +00:00
if (!db)
return;
2017-04-08 18:36:32 +00:00
ClangCursor cursor(ref->cursor);
ClangCursor lex_parent(fromContainer(ref->container));
ClangCursor referenced;
if (ref->referencedEntity)
referenced = ref->referencedEntity->cursor;
2017-02-20 00:56:56 +00:00
switch (ref->referencedEntity->kind) {
case CXIdxEntity_Unexposed:
LOG_S(INFO) << "CXIdxEntity_Unexposed " << cursor.get_spell_name();
break;
2017-03-17 07:58:41 +00:00
case CXIdxEntity_CXXNamespace: {
IndexType& ns = db->ToType(referenced.get_usr_hash());
AddUse(db, ns.uses, cursor.get_spell(), fromContainer(ref->container));
2017-03-17 07:58:41 +00:00
break;
2017-02-20 00:56:56 +00:00
}
2017-03-17 07:58:41 +00:00
case CXIdxEntity_CXXNamespaceAlias: {
IndexType& ns = db->ToType(referenced.get_usr_hash());
AddUse(db, ns.uses, cursor.get_spell(), fromContainer(ref->container));
if (!ns.def.spell) {
ClangCursor sem_parent = referenced.get_semantic_parent();
ClangCursor lex_parent = referenced.get_lexical_parent();
2018-05-08 07:35:32 +00:00
CXFile referenced_file;
Range spell = referenced.get_spell(&referenced_file);
if (file == referenced_file) {
ns.def.spell = SetUse(db, spell, sem_parent, Role::Definition);
ns.def.extent =
SetUse(db, referenced.get_extent(), lex_parent, Role::None);
std::string name = referenced.get_spell_name();
SetTypeName(ns, referenced, nullptr, name.c_str(), param);
}
}
break;
}
2017-12-15 20:14:57 +00:00
case CXIdxEntity_ObjCProperty:
case CXIdxEntity_ObjCIvar:
2017-03-17 07:58:41 +00:00
case CXIdxEntity_EnumConstant:
case CXIdxEntity_CXXStaticVariable:
case CXIdxEntity_Variable:
case CXIdxEntity_Field: {
2018-03-06 04:46:45 +00:00
Range loc = cursor.get_spell();
CheckTypeDependentMemberRefExpr(&loc, cursor, param, db);
2017-04-03 01:34:15 +00:00
2017-03-17 07:58:41 +00:00
referenced = referenced.template_specialization_to_template_definition();
IndexVar& var = db->ToVar(referenced);
// Lambda paramaters are not processed by OnIndexDeclaration and
// may not have a short_name yet. Note that we only process the lambda
// parameter as a definition if it is in the same file as the reference,
// as lambdas cannot be split across files.
if (!var.def.detailed_name[0]) {
CXFile referenced_file;
2018-02-18 18:07:13 +00:00
Range spell = referenced.get_spell(&referenced_file);
if (file == referenced_file) {
var.def.spell = SetUse(db, spell, lex_parent, Role::Definition);
var.def.extent =
2018-02-22 07:34:32 +00:00
SetUse(db, referenced.get_extent(), lex_parent, Role::None);
2017-12-23 16:01:43 +00:00
// TODO Some of the logic here duplicates CXIdxEntity_Variable branch
// of OnIndexDeclaration. But there `decl` is of type CXIdxDeclInfo
// and has more information, thus not easy to reuse the code.
2018-02-18 18:07:13 +00:00
SetVarDetail(var, referenced.get_spell_name(), referenced, nullptr,
true, db, param);
var.def.kind = lsSymbolKind::Parameter;
}
}
AddUse(db, var.uses, loc, fromContainer(ref->container),
GetRole(ref, Role::Reference));
2017-03-17 07:58:41 +00:00
break;
2017-02-20 00:56:56 +00:00
}
2017-03-17 07:58:41 +00:00
case CXIdxEntity_CXXConversionFunction:
case CXIdxEntity_CXXStaticMethod:
case CXIdxEntity_CXXInstanceMethod:
2017-12-15 20:14:57 +00:00
case CXIdxEntity_ObjCInstanceMethod:
case CXIdxEntity_ObjCClassMethod:
2017-03-17 07:58:41 +00:00
case CXIdxEntity_Function:
case CXIdxEntity_CXXConstructor:
case CXIdxEntity_CXXDestructor: {
// TODO: Redirect container to constructor for the following example, ie,
// we should be inserting an outgoing function call from the Foo
// ctor.
//
// int Gen() { return 5; }
// class Foo {
// int x = Gen();
// }
// TODO: search full history?
2018-03-06 04:46:45 +00:00
Range loc = cursor.get_spell();
2017-04-03 01:34:15 +00:00
IndexFunc& called = db->ToFunc(HashUsr(ref->referencedEntity->USR));
2017-05-23 06:47:27 +00:00
std::string_view short_name = called.def.Name(false);
2017-05-23 06:47:27 +00:00
// libclang doesn't provide a nice api to check if the given function
// call is implicit. ref->kind should probably work (it's either direct
// or implicit), but libclang only supports implicit for objective-c.
2017-09-22 01:14:57 +00:00
bool is_implicit =
CanBeCalledImplicitly(ref->referencedEntity->kind) &&
// Treats empty short_name as an implicit call like implicit move
// constructor in `vector<int> a = f();`
(short_name.empty() ||
// For explicit destructor call, ref->cursor may be "~" while
// called->def.short_name is "~A"
// "~A" is not a substring of ref->cursor, but we should take this
// case as not `is_implicit`.
(short_name[0] != '~' &&
!CursorSpellingContainsString(ref->cursor, param->tu->cx_tu,
short_name)));
2017-05-23 06:47:27 +00:00
2018-01-11 02:43:01 +00:00
// Extents have larger ranges and thus less specific, and will be
// overriden by other functions if exist.
//
// Type-dependent member access expressions do not have useful spelling
2018-01-11 02:43:01 +00:00
// ranges. See the comment above for the CXIdxEntity_Field case.
if (is_implicit)
2018-03-06 04:46:45 +00:00
loc = cursor.get_extent();
else
2018-03-06 04:46:45 +00:00
CheckTypeDependentMemberRefExpr(&loc, cursor, param, db);
OnIndexReference_Function(
db, loc, ref->container->cursor, called,
GetRole(ref, Role::Call) |
(is_implicit ? Role::Implicit : Role::None));
2017-03-17 07:58:41 +00:00
// Checks if |str| starts with |start|. Ignores case.
auto str_begin = [](const char* start, const char* str) {
while (*start && *str) {
char a = tolower(*start);
char b = tolower(*str);
if (a != b)
return false;
++start;
++str;
}
return !*start;
};
bool is_template = ref->referencedEntity->templateKind !=
CXIdxEntityCXXTemplateKind::CXIdxEntity_NonTemplate;
2018-04-04 06:05:41 +00:00
if (g_config->index.attributeMakeCallsToCtor && is_template &&
str_begin("make", ref->referencedEntity->name)) {
// Try to find the return type of called function. That type will have
// the constructor function we add a usage to.
2018-03-31 03:16:33 +00:00
std::optional<ClangCursor> opt_found_type = FindType(ref->cursor);
if (opt_found_type) {
2018-01-13 08:10:39 +00:00
Usr ctor_type_usr = opt_found_type->get_referenced().get_usr_hash();
ClangCursor call_cursor = ref->cursor;
// Build a type description from the parameters of the call, so we
// can try to find a constructor with the same type description.
std::vector<std::string> call_type_desc;
for (ClangType type : call_cursor.get_type().get_arguments()) {
2018-02-18 18:07:13 +00:00
std::string type_desc = type.get_spell_name();
if (!type_desc.empty())
call_type_desc.push_back(type_desc);
}
// Try to find the constructor and add a reference.
2018-03-31 03:16:33 +00:00
std::optional<Usr> ctor_usr =
param->ctors.TryFindConstructorUsr(ctor_type_usr, call_type_desc);
if (ctor_usr) {
IndexFunc& ctor = db->ToFunc(*ctor_usr);
ctor.uses.push_back(
Use{{loc, 0, SymbolKind::File, Role::Call | Role::Implicit}});
}
}
}
2017-03-17 07:58:41 +00:00
break;
}
2017-02-17 09:57:44 +00:00
2017-12-15 20:14:57 +00:00
case CXIdxEntity_ObjCCategory:
case CXIdxEntity_ObjCProtocol:
case CXIdxEntity_ObjCClass:
2017-03-17 07:58:41 +00:00
case CXIdxEntity_Typedef:
2018-02-22 07:34:32 +00:00
case CXIdxEntity_CXXInterface: // MSVC __interface
2017-03-17 07:58:41 +00:00
case CXIdxEntity_CXXTypeAlias:
case CXIdxEntity_Enum:
case CXIdxEntity_Union:
case CXIdxEntity_Struct:
case CXIdxEntity_CXXClass: {
2018-03-06 04:46:45 +00:00
referenced = referenced.template_specialization_to_template_definition();
IndexType& ref_type = db->ToType(referenced);
if (!ref->parentEntity || IsDeclContext(ref->parentEntity->kind))
AddUseSpell(db, ref_type.declarations, ref->cursor);
else
AddUseSpell(db, ref_type.uses, ref->cursor);
2017-03-17 07:58:41 +00:00
break;
2017-02-26 01:08:05 +00:00
}
2017-02-20 00:56:56 +00:00
}
}
2017-02-17 09:57:44 +00:00
2018-05-09 05:01:58 +00:00
std::vector<std::unique_ptr<IndexFile>> ClangIndexer::Index(
VFS* vfs,
std::string file,
2017-09-27 06:03:43 +00:00
const std::vector<std::string>& args,
2018-06-01 04:21:34 +00:00
const std::vector<FileContents>& file_contents) {
2018-04-04 06:05:41 +00:00
if (!g_config->index.enabled)
2018-04-02 07:22:12 +00:00
return {};
2017-04-19 00:05:14 +00:00
file = NormalizePath(file);
2017-03-11 02:24:51 +00:00
2018-07-03 22:47:43 +00:00
static Timer timer("parse", "parse tu");
timer.startTimer();
2017-04-14 22:58:07 +00:00
std::vector<CXUnsavedFile> unsaved_files;
2017-07-30 04:24:02 +00:00
for (const FileContents& contents : file_contents) {
CXUnsavedFile unsaved;
2017-07-30 04:24:02 +00:00
unsaved.Filename = contents.path.c_str();
unsaved.Contents = contents.content.c_str();
unsaved.Length = (unsigned long)contents.content.size();
unsaved_files.push_back(unsaved);
}
2017-07-30 04:24:02 +00:00
std::unique_ptr<ClangTranslationUnit> tu = ClangTranslationUnit::Create(
2018-05-09 05:01:58 +00:00
&index, file, args, unsaved_files,
2017-10-31 19:49:19 +00:00
CXTranslationUnit_KeepGoing |
CXTranslationUnit_DetailedPreprocessingRecord);
if (!tu)
2018-04-02 07:22:12 +00:00
return {};
2017-02-16 09:35:30 +00:00
timer.stopTimer();
2018-06-01 04:21:34 +00:00
return ParseWithTu(vfs, tu.get(), &index, file, args, unsaved_files);
2017-09-27 06:03:43 +00:00
}
2018-04-02 07:22:12 +00:00
std::vector<std::unique_ptr<IndexFile>> ParseWithTu(
VFS* vfs,
ClangTranslationUnit* tu,
ClangIndex* index,
2017-09-27 06:03:43 +00:00
const std::string& file,
const std::vector<std::string>& args,
const std::vector<CXUnsavedFile>& file_contents) {
2017-12-01 17:57:03 +00:00
IndexerCallbacks callback = {0};
// Available callbacks:
// - abortQuery
// - enteredMainFile
// - ppIncludedFile
// - importedASTFile
// - startedTranslationUnit
callback.diagnostic = &OnIndexDiagnostic;
callback.ppIncludedFile = &OnIndexIncludedFile;
callback.indexDeclaration = &OnIndexDeclaration;
callback.indexEntityReference = &OnIndexReference;
2017-02-20 00:56:56 +00:00
FileConsumer file_consumer(vfs, file);
2018-04-04 06:05:41 +00:00
IndexParam param(tu, &file_consumer);
2017-09-27 06:03:43 +00:00
for (const CXUnsavedFile& contents : file_contents) {
param.file_contents[contents.Filename] = FileContents(
2017-12-19 07:05:12 +00:00
contents.Filename, std::string(contents.Contents, contents.Length));
}
2017-03-06 06:47:37 +00:00
2017-09-27 06:03:43 +00:00
CXFile cx_file = clang_getFile(tu->cx_tu, file.c_str());
param.primary_file = ConsumeFile(&param, cx_file);
CXIndexAction index_action = clang_IndexAction_create(index->cx_index);
2017-12-01 17:57:03 +00:00
// |index_result| is a CXErrorCode instance.
int index_result = clang_indexTranslationUnit(
index_action, &param, &callback, sizeof(IndexerCallbacks),
CXIndexOpt_IndexFunctionLocalSymbols |
CXIndexOpt_SkipParsedBodiesInSession |
CXIndexOpt_IndexImplicitTemplateInstantiations,
tu->cx_tu);
if (index_result != CXError_Success) {
2018-01-20 07:56:49 +00:00
LOG_S(ERROR) << "Indexing " << file
<< " failed with errno=" << index_result;
2018-04-02 07:22:12 +00:00
return {};
2017-12-01 17:57:03 +00:00
}
2017-02-20 00:56:56 +00:00
clang_IndexAction_dispose(index_action);
ClangCursor(clang_getTranslationUnitCursor(tu->cx_tu))
.VisitChildren(&VisitMacroDefinitionAndExpansions, &param);
2018-01-06 17:28:55 +00:00
std::unordered_map<std::string, int> inc_to_line;
// TODO
if (param.primary_file)
2018-01-11 02:43:01 +00:00
for (auto& inc : param.primary_file->includes)
inc_to_line[inc.resolved_path] = inc.line;
2018-01-06 17:28:55 +00:00
2017-04-08 22:54:36 +00:00
auto result = param.file_consumer->TakeLocalState();
2017-07-30 04:24:02 +00:00
for (std::unique_ptr<IndexFile>& entry : result) {
entry->import_file = file;
entry->args = args;
for (auto& it : entry->usr2func) {
2018-03-07 23:08:50 +00:00
// e.g. declaration + out-of-line definition
Uniquify(it.second.derived);
Uniquify(it.second.uses);
2018-03-07 23:08:50 +00:00
}
for (auto& it : entry->usr2type) {
Uniquify(it.second.derived);
Uniquify(it.second.uses);
// e.g. declaration + out-of-line definition
Uniquify(it.second.def.funcs);
}
for (auto& it : entry->usr2var)
Uniquify(it.second.uses);
2018-01-06 17:28:55 +00:00
if (param.primary_file) {
// If there are errors, show at least one at the include position.
auto it = inc_to_line.find(entry->path);
if (it != inc_to_line.end()) {
int line = it->second;
for (auto ls_diagnostic : entry->diagnostics_) {
if (ls_diagnostic.severity != lsDiagnosticSeverity::Error)
continue;
ls_diagnostic.range =
2018-04-08 00:10:54 +00:00
lsRange{lsPosition{line, 10}, lsPosition{line, 10}};
param.primary_file->diagnostics_.push_back(ls_diagnostic);
break;
}
2018-01-06 17:28:55 +00:00
}
}
2017-07-30 04:24:02 +00:00
// Update file contents and modification time.
entry->last_write_time = param.file2write_time[entry->path];
2017-07-30 04:24:02 +00:00
// Update dependencies for the file. Do not include the file in its own
// dependency set.
for (const std::string& path : param.seen_files)
if (path != entry->path && path != entry->import_file)
entry->dependencies[path] = param.file2write_time[path];
2017-04-08 22:54:36 +00:00
}
2017-04-19 00:05:14 +00:00
2018-04-02 07:22:12 +00:00
return result;
2017-03-22 17:16:09 +00:00
}
bool ConcatTypeAndName(std::string& type, const std::string& name) {
bool ret = false;
if (type.size() &&
(type.back() != ' ' && type.back() != '*' && type.back() != '&')) {
type.push_back(' ');
ret = true;
}
type.append(name);
return ret;
}
void IndexInit() {
clang_enableStackTraces();
if (!getenv("LIBCLANG_DISABLE_CRASH_RECOVERY"))
clang_toggleCrashRecovery(1);
2017-04-18 23:49:55 +00:00
}
// |SymbolRef| is serialized this way.
// |Use| also uses this though it has an extra field |file|,
// which is not used by Index* so it does not need to be serialized.
void Reflect(Reader& visitor, Reference& value) {
if (visitor.Format() == SerializeFormat::Json) {
std::string t = visitor.GetString();
char* s = const_cast<char*>(t.c_str());
value.range = Range::FromString(s);
s = strchr(s, '|');
value.usr = strtoull(s + 1, &s, 10);
value.kind = static_cast<SymbolKind>(strtol(s + 1, &s, 10));
value.role = static_cast<Role>(strtol(s + 1, &s, 10));
} else {
Reflect(visitor, value.range);
Reflect(visitor, value.usr);
2018-02-09 17:42:10 +00:00
Reflect(visitor, value.kind);
Reflect(visitor, value.role);
}
}
void Reflect(Writer& visitor, Reference& value) {
if (visitor.Format() == SerializeFormat::Json) {
char buf[99];
snprintf(buf, sizeof buf, "%s|%" PRIu64 "|%d|%d",
value.range.ToString().c_str(), value.usr, int(value.kind),
int(value.role));
std::string s(buf);
Reflect(visitor, s);
} else {
Reflect(visitor, value.range);
Reflect(visitor, value.usr);
2018-02-09 17:42:10 +00:00
Reflect(visitor, value.kind);
Reflect(visitor, value.role);
}
}