mirror of
https://github.com/MaskRay/ccls.git
synced 2024-11-26 09:31:59 +00:00
2233 lines
77 KiB
C++
2233 lines
77 KiB
C++
#include "indexer.h"
|
|
|
|
#include "log.hh"
|
|
#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>
|
|
#include <limits.h>
|
|
#include <algorithm>
|
|
#include <chrono>
|
|
#include <unordered_set>
|
|
|
|
#if CINDEX_VERSION >= 48
|
|
#define CINDEX_HAVE_ROLE 1
|
|
#endif
|
|
|
|
namespace {
|
|
|
|
// 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;
|
|
};
|
|
|
|
// 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) {
|
|
case CXCursor_TranslationUnit:
|
|
return SymbolKind::File;
|
|
|
|
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:
|
|
return SymbolKind::Func;
|
|
|
|
case CXCursor_StructDecl:
|
|
case CXCursor_UnionDecl:
|
|
case CXCursor_ClassDecl:
|
|
case CXCursor_EnumDecl:
|
|
case CXCursor_ObjCInterfaceDecl:
|
|
case CXCursor_ObjCCategoryDecl:
|
|
case CXCursor_ObjCImplementationDecl:
|
|
case CXCursor_Namespace:
|
|
return SymbolKind::Type;
|
|
|
|
default:
|
|
return SymbolKind::Invalid;
|
|
}
|
|
}
|
|
|
|
// Inverse of libclang/CXIndexDataConsumer.cpp getEntityKindFromSymbolKind
|
|
lsSymbolKind GetSymbolKind(CXIdxEntityKind kind) {
|
|
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;
|
|
}
|
|
|
|
return lsSymbolKind::Unknown;
|
|
}
|
|
|
|
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 {
|
|
Usr usr;
|
|
std::vector<std::string> param_type_desc;
|
|
};
|
|
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|.
|
|
std::optional<Usr> TryFindConstructorUsr(
|
|
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())
|
|
return std::nullopt;
|
|
const std::vector<Constructor>& ctors = ctors_it->second;
|
|
if (ctors.empty())
|
|
return std::nullopt;
|
|
|
|
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 {
|
|
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;
|
|
|
|
// 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)
|
|
: 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, ¶m->file_contents);
|
|
|
|
// 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.
|
|
// https://reviews.llvm.org/D42893
|
|
// https://github.com/cquery-project/cquery/issues/413
|
|
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;
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
// 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) {
|
|
case CXIdxEntity_CXXConstructor:
|
|
case CXIdxEntity_CXXConversionFunction:
|
|
case CXIdxEntity_CXXDestructor:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Returns true if the cursor spelling contains the given string. This is
|
|
// useful to check for implicit function calls.
|
|
bool CursorSpellingContainsString(CXCursor cursor,
|
|
CXTranslationUnit cx_tu,
|
|
std::string_view needle) {
|
|
CXSourceRange range = clang_Cursor_getSpellingNameRange(cursor, 0, 0);
|
|
CXToken* tokens;
|
|
unsigned num_tokens;
|
|
clang_tokenize(cx_tu, range, &tokens, &num_tokens);
|
|
|
|
bool result = false;
|
|
|
|
for (unsigned i = 0; i < num_tokens; ++i) {
|
|
CXString name = clang_getTokenSpelling(cx_tu, tokens[i]);
|
|
if (needle == clang_getCString(name)) {
|
|
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.
|
|
std::string GetDocumentContentInRange(CXTranslationUnit cx_tu,
|
|
CXSourceRange range) {
|
|
std::string result;
|
|
|
|
CXToken* tokens;
|
|
unsigned num_tokens;
|
|
clang_tokenize(cx_tu, range, &tokens, &num_tokens);
|
|
|
|
std::optional<Range> previous_token_range;
|
|
|
|
for (unsigned i = 0; i < num_tokens; ++i) {
|
|
// Add whitespace between the previous token and this one.
|
|
Range token_range =
|
|
ResolveCXSourceRange(clang_getTokenExtent(cx_tu, tokens[i]));
|
|
if (previous_token_range) {
|
|
// Insert newlines.
|
|
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.
|
|
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|.
|
|
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}};
|
|
default:
|
|
return Use{{range, 0, SymbolKind::File, role}};
|
|
}
|
|
}
|
|
|
|
const char* GetAnonName(CXCursorKind kind) {
|
|
switch (kind) {
|
|
case CXCursor_ClassDecl:
|
|
return "(anon class)";
|
|
case CXCursor_EnumDecl:
|
|
return "(anon enum)";
|
|
case CXCursor_Namespace:
|
|
return "(anon ns)";
|
|
case CXCursor_StructDecl:
|
|
return "(anon struct)";
|
|
case CXCursor_UnionDecl:
|
|
return "(anon union)";
|
|
default:
|
|
return "(anon)";
|
|
}
|
|
}
|
|
|
|
void SetTypeName(IndexType& type,
|
|
const ClangCursor& cursor,
|
|
const CXIdxContainerInfo* container,
|
|
const char* name,
|
|
IndexParam* param) {
|
|
CXIdxContainerInfo parent;
|
|
// |name| can be null in an anonymous struct (see
|
|
// tests/types/anonymous_struct.cc).
|
|
if (!name)
|
|
name = GetAnonName(cursor.get_kind());
|
|
if (!container)
|
|
parent.cursor = cursor.get_semantic_parent().cx_cursor;
|
|
// 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) =
|
|
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 =
|
|
type.get_declaration().template_specialization_to_template_definition();
|
|
std::optional<Usr> usr = declaration.get_opt_usr_hash();
|
|
if (!usr)
|
|
return nullptr;
|
|
IndexType& typ = db->ToType(*usr);
|
|
if (!typ.def.detailed_name[0]) {
|
|
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";
|
|
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);
|
|
|
|
if (cursor.get_kind() == CXCursor_EnumConstantDecl && semanticContainer) {
|
|
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);
|
|
} 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 =
|
|
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(
|
|
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
|
|
|
|
// 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) {}
|
|
|
|
IndexFunc& IndexFile::ToFunc(Usr usr) {
|
|
auto ret = usr2func.try_emplace(usr);
|
|
if (ret.second)
|
|
ret.first->second.usr = usr;
|
|
return ret.first->second;
|
|
}
|
|
|
|
IndexType& IndexFile::ToType(Usr usr) {
|
|
auto ret = usr2type.try_emplace(usr);
|
|
if (ret.second)
|
|
ret.first->second.usr = usr;
|
|
return ret.first->second;
|
|
}
|
|
|
|
IndexVar& IndexFile::ToVar(Usr usr) {
|
|
auto ret = usr2var.try_emplace(usr);
|
|
if (ret.second)
|
|
ret.first->second.usr = usr;
|
|
return ret.first->second;
|
|
}
|
|
|
|
std::string IndexFile::ToString() {
|
|
return ccls::Serialize(SerializeFormat::Json, *this);
|
|
}
|
|
|
|
void Uniquify(std::vector<Usr>& usrs) {
|
|
std::unordered_set<Usr> seen;
|
|
size_t n = 0;
|
|
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) {
|
|
std::unordered_set<Range> seen;
|
|
size_t n = 0;
|
|
for (size_t i = 0; i < uses.size(); i++) {
|
|
if (seen.insert(uses[i].range).second)
|
|
uses[n++] = uses[i];
|
|
}
|
|
uses.resize(n);
|
|
}
|
|
|
|
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}});
|
|
break;
|
|
default:
|
|
uses.push_back(Use{{range, 0, SymbolKind::File, role}});
|
|
break;
|
|
}
|
|
}
|
|
|
|
CXCursor fromContainer(const CXIdxContainerInfo* parent) {
|
|
return parent ? parent->cursor : clang_getNullCursor();
|
|
}
|
|
|
|
void AddUseSpell(IndexFile* db, std::vector<Use>& uses, ClangCursor cursor) {
|
|
AddUse(db, uses, cursor.get_spell(), cursor.get_lexical_parent().cx_cursor);
|
|
}
|
|
|
|
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);
|
|
// 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);
|
|
// Skip empty diagnostic.
|
|
if (!line && !column)
|
|
continue;
|
|
IndexFile* db = ConsumeFile(param, file);
|
|
if (!db)
|
|
continue;
|
|
|
|
// Build diagnostic.
|
|
std::optional<lsDiagnostic> ls_diagnostic =
|
|
BuildAndDisposeDiagnostic(diagnostic, db->path);
|
|
if (ls_diagnostic)
|
|
db->diagnostics_.push_back(*ls_diagnostic);
|
|
}
|
|
}
|
|
|
|
CXIdxClientFile OnIndexIncludedFile(CXClientData client_data,
|
|
const CXIdxIncludedFileInfo* file) {
|
|
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--;
|
|
|
|
IndexFile* db = ConsumeFile(param, cx_file);
|
|
if (!db)
|
|
return nullptr;
|
|
|
|
IndexInclude include;
|
|
include.line = line;
|
|
include.resolved_path = FileName(file->file);
|
|
if (include.resolved_path.size())
|
|
db->includes.push_back(include);
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
struct FindChildOfKindParam {
|
|
CXCursorKind target_kind;
|
|
std::optional<ClangCursor> result;
|
|
|
|
FindChildOfKindParam(CXCursorKind target_kind) : target_kind(target_kind) {}
|
|
};
|
|
|
|
ClangCursor::VisitResult FindTypeVisitor(ClangCursor cursor,
|
|
ClangCursor parent,
|
|
std::optional<ClangCursor>* result) {
|
|
switch (cursor.get_kind()) {
|
|
case CXCursor_TypeRef:
|
|
case CXCursor_TemplateRef:
|
|
*result = cursor;
|
|
return ClangCursor::VisitResult::Break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return ClangCursor::VisitResult::Recurse;
|
|
}
|
|
|
|
std::optional<ClangCursor> FindType(ClangCursor cursor) {
|
|
std::optional<ClangCursor> result;
|
|
cursor.VisitChildren(&FindTypeVisitor, &result);
|
|
return result;
|
|
}
|
|
|
|
bool IsTypeDefinition(const CXIdxContainerInfo* container) {
|
|
if (!container)
|
|
return false;
|
|
return GetSymbolKind(container->cursor.kind) == SymbolKind::Type;
|
|
}
|
|
|
|
struct VisitDeclForTypeUsageParam {
|
|
IndexFile* db;
|
|
IndexType* toplevel_type;
|
|
int has_processed_any = false;
|
|
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,
|
|
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.
|
|
// |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;
|
|
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;
|
|
}
|
|
}
|
|
|
|
std::optional<Usr> referenced_usr =
|
|
cursor.get_referenced()
|
|
.template_specialization_to_template_definition()
|
|
.get_opt_usr_hash();
|
|
// In STL this may be empty.
|
|
if (!referenced_usr)
|
|
return;
|
|
|
|
IndexType& ref_type = db->ToType(*referenced_usr);
|
|
|
|
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);
|
|
}
|
|
|
|
ClangCursor::VisitResult VisitDeclForTypeUsageVisitor(
|
|
ClangCursor cursor,
|
|
ClangCursor parent,
|
|
VisitDeclForTypeUsageParam* param) {
|
|
switch (cursor.get_kind()) {
|
|
case CXCursor_TemplateRef:
|
|
case CXCursor_TypeRef:
|
|
if (param->previous_cursor) {
|
|
VisitDeclForTypeUsageVisitorHandler(param->previous_cursor.value(),
|
|
param);
|
|
}
|
|
|
|
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
|
|
// things that can logically appear as part of an inline variable
|
|
// initializer,
|
|
// ie,
|
|
//
|
|
// class Foo {
|
|
// int x = (Foo)3;
|
|
// }
|
|
case CXCursor_CallExpr:
|
|
case CXCursor_CStyleCastExpr:
|
|
case CXCursor_CXXStaticCastExpr:
|
|
case CXCursor_CXXReinterpretCastExpr:
|
|
return ClangCursor::VisitResult::Recurse;
|
|
|
|
default:
|
|
return ClangCursor::VisitResult::Continue;
|
|
}
|
|
|
|
return ClangCursor::VisitResult::Continue;
|
|
}
|
|
|
|
// Add usages to any seen TypeRef or TemplateRef under the given |decl_cursor|.
|
|
// 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
|
|
//
|
|
//
|
|
// Here is another example:
|
|
//
|
|
// enum A {};
|
|
// enum B {};
|
|
//
|
|
// template<typename T>
|
|
// struct Foo {
|
|
// struct Inner {};
|
|
// };
|
|
//
|
|
// Foo<A>::Inner a;
|
|
// Foo<B> b;
|
|
//
|
|
// =>
|
|
//
|
|
// 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() {}
|
|
//
|
|
// 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;
|
|
if (IsTypeDefinition(semantic_container) &&
|
|
!IsTypeDefinition(lexical_container)) {
|
|
//
|
|
// 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;
|
|
}
|
|
|
|
VisitDeclForTypeUsageParam param(db, toplevel_type);
|
|
decl_cursor.VisitChildren(&VisitDeclForTypeUsageVisitor, ¶m);
|
|
|
|
// 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(), ¶m);
|
|
} else {
|
|
// If we are not processing the last type ref, it *must* be a TypeRef or
|
|
// TemplateRef.
|
|
//
|
|
// We will not visit every child if the is_interseting is false, so
|
|
// previous_cursor
|
|
// may not point to the last TemplateRef.
|
|
assert(param.previous_cursor.has_value() == false ||
|
|
(param.previous_cursor.value().get_kind() == CXCursor_TypeRef ||
|
|
param.previous_cursor.value().get_kind() == CXCursor_TemplateRef));
|
|
}
|
|
|
|
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());
|
|
}
|
|
|
|
// 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) {
|
|
/*
|
|
We need to index the |DeclRefExpr| below (ie, |var| inside of
|
|
Foo<int>::var).
|
|
|
|
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()) {
|
|
case CXCursor_DeclRefExpr: {
|
|
if (cursor.get_referenced().get_kind() != CXCursor_VarDecl)
|
|
break;
|
|
|
|
// TODO: when we resolve the template type to the definition, we get a
|
|
// different Usr.
|
|
|
|
// ClangCursor ref =
|
|
// cursor.get_referenced().template_specialization_to_template_definition().get_type().strip_qualifiers().get_usr_hash();
|
|
// 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()
|
|
.get_opt_usr_hash();
|
|
if (!ref_usr)
|
|
break;
|
|
IndexVar& ref_var = db->ToVar(*ref_usr);
|
|
AddUseSpell(db, ref_var.uses, cursor);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return ClangCursor::VisitResult::Recurse;
|
|
}
|
|
|
|
ClangCursor::VisitResult VisitMacroDefinitionAndExpansions(ClangCursor cursor,
|
|
ClangCursor parent,
|
|
IndexParam* param) {
|
|
switch (cursor.get_kind()) {
|
|
case CXCursor_MacroDefinition:
|
|
case CXCursor_MacroExpansion: {
|
|
// Resolve location, find IndexFile instance.
|
|
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)
|
|
|
|
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;
|
|
if (g_config->index.comments)
|
|
var_def.def.comments = Intern(cursor.get_comments());
|
|
var_def.def.spell =
|
|
SetUse(db, decl_loc_spelling, parent, Role::Definition);
|
|
var_def.def.extent = SetUse(
|
|
db, ResolveCXSourceRange(cx_extent, nullptr), parent, Role::None);
|
|
} else
|
|
AddUse(db, var_def.uses, decl_loc_spelling, parent);
|
|
|
|
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:
|
|
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]) {
|
|
ClangCursor sem_parent = ref_cursor.get_semantic_parent();
|
|
ClangCursor lex_parent = ref_cursor.get_lexical_parent();
|
|
ref_var.def.spell =
|
|
SetUse(db, ref_cursor.get_spell(), sem_parent, Role::Definition);
|
|
ref_var.def.extent =
|
|
SetUse(db, ref_cursor.get_extent(), lex_parent, Role::None);
|
|
ref_var.def.kind = lsSymbolKind::TypeParameter;
|
|
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.
|
|
// See https://github.com/cquery-project/cquery/issues/252
|
|
AddUse(db, ref_type.uses, ref_cursor.get_extent(),
|
|
ref_cursor.get_lexical_parent());
|
|
}
|
|
}
|
|
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());
|
|
OnIndexReference_Function(db, cursor.get_spell(), data->container,
|
|
called, Role::Call);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
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]) {
|
|
ClangCursor sem_parent = ref_cursor.get_semantic_parent();
|
|
ClangCursor lex_parent = ref_cursor.get_lexical_parent();
|
|
ref_type.def.spell =
|
|
SetUse(db, ref_cursor.get_spell(), sem_parent, Role::Definition);
|
|
ref_type.def.extent =
|
|
SetUse(db, ref_cursor.get_extent(), lex_parent, Role::None);
|
|
#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);
|
|
// 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]) {
|
|
ClangCursor sem_parent = ref_cursor.get_semantic_parent();
|
|
ClangCursor lex_parent = ref_cursor.get_lexical_parent();
|
|
ref_type.def.spell =
|
|
SetUse(db, ref_cursor.get_spell(), sem_parent, Role::Definition);
|
|
ref_type.def.extent =
|
|
SetUse(db, ref_cursor.get_extent(), lex_parent, Role::None);
|
|
#if 0 && CINDEX_HAVE_PRETTY
|
|
// 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(
|
|
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.
|
|
ClangCursor cursor(container->cursor);
|
|
std::vector<ClangCursor> namespaces;
|
|
std::string qualifier;
|
|
while (cursor.get_kind() != CXCursor_TranslationUnit &&
|
|
GetSymbolKind(cursor.get_kind()) == SymbolKind::Type) {
|
|
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--;
|
|
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 += "::";
|
|
usr2qualified_name[namespaces[i].get_usr_hash()] = qualifier;
|
|
}
|
|
int16_t pos = qualifier.size();
|
|
qualifier.append(unqualified_name);
|
|
return {qualifier, pos, int16_t(unqualified_name.size())};
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
CXFile file;
|
|
clang_getSpellingLocation(clang_indexLoc_getCXSourceLocation(decl->loc),
|
|
&file, nullptr, nullptr, nullptr);
|
|
IndexFile* db = ConsumeFile(param, file);
|
|
if (!db)
|
|
return;
|
|
|
|
// The language of this declaration
|
|
LanguageId decl_lang = [&decl]() {
|
|
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;
|
|
};
|
|
}();
|
|
|
|
// Only update the file language if the new language is "greater" than the old
|
|
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;
|
|
|
|
switch (decl->entityInfo->kind) {
|
|
case CXIdxEntity_Unexposed:
|
|
LOG_S(INFO) << "CXIdxEntity_Unexposed " << cursor.get_spell_name();
|
|
break;
|
|
|
|
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]) {
|
|
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);
|
|
if (decl->semanticContainer) {
|
|
IndexType& parent = db->ToType(decl->semanticContainer->cursor);
|
|
parent.derived.push_back(ns.usr);
|
|
ns.def.bases.push_back(parent.usr);
|
|
}
|
|
}
|
|
AddUse(db, ns.uses, spell, lex_parent);
|
|
break;
|
|
}
|
|
|
|
case CXIdxEntity_CXXNamespaceAlias:
|
|
assert(false && "CXXNamespaceAlias");
|
|
break;
|
|
|
|
case CXIdxEntity_ObjCProperty:
|
|
case CXIdxEntity_ObjCIvar:
|
|
case CXIdxEntity_EnumConstant:
|
|
case CXIdxEntity_Field:
|
|
case CXIdxEntity_Variable:
|
|
case CXIdxEntity_CXXStaticVariable: {
|
|
Range spell = cursor.get_spell();
|
|
|
|
// Do not index implicit template instantiations.
|
|
if (cursor != cursor.template_specialization_to_template_definition())
|
|
break;
|
|
|
|
IndexVar& var = db->ToVar(HashUsr(decl->entityInfo->USR));
|
|
|
|
// 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 =
|
|
SetUse(db, cursor.get_extent(), lex_parent, Role::None);
|
|
}
|
|
|
|
cursor.VisitChildren(&AddDeclInitializerUsagesVisitor, db);
|
|
|
|
// 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);
|
|
|
|
// 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;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case CXIdxEntity_ObjCInstanceMethod:
|
|
case CXIdxEntity_ObjCClassMethod:
|
|
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();
|
|
|
|
ClangCursor decl_cursor_resolved =
|
|
cursor.template_specialization_to_template_definition();
|
|
bool is_template_specialization = cursor != decl_cursor_resolved;
|
|
|
|
IndexFunc& func = db->ToFunc(decl_cursor_resolved);
|
|
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));
|
|
|
|
// 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,
|
|
decl->lexicalContainer);
|
|
|
|
// 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);
|
|
} else {
|
|
func.declarations.push_back(
|
|
SetUse(db, spell, lex_parent, Role::Declaration));
|
|
}
|
|
|
|
// 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;
|
|
data.param = param;
|
|
data.container = cursor;
|
|
cursor.VisitChildren(&TemplateVisitor, &data);
|
|
}
|
|
|
|
// 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.
|
|
if (IsTypeDefinition(decl->semanticContainer)) {
|
|
IndexType& declaring_type =
|
|
db->ToType(decl->semanticContainer->cursor);
|
|
func.def.declaring_type = declaring_type.usr;
|
|
|
|
// Mark a type reference at the ctor/dtor location.
|
|
if (decl->entityInfo->kind == CXIdxEntity_CXXConstructor)
|
|
AddUse(db, declaring_type.uses, spell,
|
|
fromContainer(decl->lexicalContainer));
|
|
|
|
// Add function to declaring type.
|
|
declaring_type.def.funcs.push_back(func.usr);
|
|
}
|
|
|
|
// Process inheritance.
|
|
if (clang_CXXMethod_isVirtual(decl->cursor)) {
|
|
CXCursor* overridden;
|
|
unsigned int num_overridden;
|
|
clang_getOverriddenCursors(decl->cursor, &overridden,
|
|
&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);
|
|
}
|
|
|
|
clang_disposeOverriddenCursors(overridden);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
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);
|
|
if (g_config->index.comments)
|
|
type.def.comments = Intern(cursor.get_comments());
|
|
|
|
// 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];
|
|
std::optional<int> extent_start = fc.ToOffset(extent.start),
|
|
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));
|
|
}
|
|
}
|
|
|
|
AddUse(db, type.uses, spell, fromContainer(decl->lexicalContainer));
|
|
break;
|
|
}
|
|
|
|
case CXIdxEntity_ObjCProtocol:
|
|
case CXIdxEntity_ObjCCategory:
|
|
case CXIdxEntity_ObjCClass:
|
|
case CXIdxEntity_Enum:
|
|
case CXIdxEntity_Union:
|
|
case CXIdxEntity_Struct:
|
|
case CXIdxEntity_CXXInterface:
|
|
case CXIdxEntity_CXXClass: {
|
|
Range spell = cursor.get_spell();
|
|
|
|
IndexType& type = db->ToType(HashUsr(decl->entityInfo->USR));
|
|
|
|
SetTypeName(type, cursor, decl->semanticContainer, decl->entityInfo->name,
|
|
param);
|
|
type.def.kind = GetSymbolKind(decl->entityInfo->kind);
|
|
if (g_config->index.comments)
|
|
type.def.comments = Intern(cursor.get_comments());
|
|
|
|
if (decl->isDefinition) {
|
|
type.def.spell = SetUse(db, spell, sem_parent, Role::Definition);
|
|
type.def.extent =
|
|
SetUse(db, cursor.get_extent(), lex_parent, Role::None);
|
|
|
|
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,
|
|
fromContainer(decl->lexicalContainer));
|
|
}
|
|
}
|
|
} else
|
|
AddUse(db, type.declarations, spell,
|
|
fromContainer(decl->lexicalContainer), Role::Declaration);
|
|
|
|
switch (decl->entityInfo->templateKind) {
|
|
default:
|
|
break;
|
|
case CXIdxEntity_TemplateSpecialization:
|
|
case CXIdxEntity_TemplatePartialSpecialization: {
|
|
// TODO Use a different dimension
|
|
ClangCursor origin_cursor =
|
|
cursor.template_specialization_to_template_definition();
|
|
IndexType& origin = db->ToType(origin_cursor);
|
|
// template<class T> class function; // not visited by
|
|
// OnIndexDeclaration template<> class function<int> {}; // current
|
|
// cursor
|
|
if (!origin.def.detailed_name[0]) {
|
|
SetTypeName(origin, origin_cursor, nullptr,
|
|
&type.def.Name(false)[0], param);
|
|
origin.def.kind = type.def.kind;
|
|
}
|
|
// TODO The name may be assigned in |ResolveToDeclarationType| but
|
|
// |spell| is std::nullopt.
|
|
CXFile origin_file;
|
|
Range origin_spell = origin_cursor.get_spell(&origin_file);
|
|
if (!origin.def.spell && file == origin_file) {
|
|
ClangCursor origin_sem = origin_cursor.get_semantic_parent();
|
|
ClangCursor origin_lex = origin_cursor.get_lexical_parent();
|
|
origin.def.spell =
|
|
SetUse(db, origin_spell, origin_sem, Role::Definition);
|
|
origin.def.extent =
|
|
SetUse(db, origin_cursor.get_extent(), origin_lex, Role::None);
|
|
}
|
|
origin.derived.push_back(type.usr);
|
|
type.def.bases.push_back(origin.usr);
|
|
[[fallthrough]];
|
|
}
|
|
case CXIdxEntity_Template: {
|
|
TemplateVisitorData data;
|
|
data.db = db;
|
|
data.container = cursor;
|
|
data.param = param;
|
|
cursor.VisitChildren(&TemplateVisitor, &data);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// 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);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 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 &&
|
|
cursor.get_spell_name().empty()) {
|
|
*spell = cursor.get_extent().RemovePrefix(spell->end);
|
|
const FileContents& fc = param->file_contents[db->path];
|
|
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.
|
|
}
|
|
}
|
|
}
|
|
|
|
void OnIndexReference(CXClientData client_data, const CXIdxEntityRefInfo* ref) {
|
|
// TODO: Use clang_getFileUniqueID
|
|
CXFile file;
|
|
clang_getSpellingLocation(clang_indexLoc_getCXSourceLocation(ref->loc), &file,
|
|
nullptr, nullptr, nullptr);
|
|
IndexParam* param = static_cast<IndexParam*>(client_data);
|
|
IndexFile* db = ConsumeFile(param, file);
|
|
if (!db)
|
|
return;
|
|
|
|
ClangCursor cursor(ref->cursor);
|
|
ClangCursor lex_parent(fromContainer(ref->container));
|
|
ClangCursor referenced;
|
|
if (ref->referencedEntity)
|
|
referenced = ref->referencedEntity->cursor;
|
|
|
|
switch (ref->referencedEntity->kind) {
|
|
case CXIdxEntity_Unexposed:
|
|
LOG_S(INFO) << "CXIdxEntity_Unexposed " << cursor.get_spell_name();
|
|
break;
|
|
|
|
case CXIdxEntity_CXXNamespace: {
|
|
IndexType& ns = db->ToType(referenced.get_usr_hash());
|
|
AddUse(db, ns.uses, cursor.get_spell(), fromContainer(ref->container));
|
|
break;
|
|
}
|
|
|
|
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();
|
|
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;
|
|
}
|
|
|
|
case CXIdxEntity_ObjCProperty:
|
|
case CXIdxEntity_ObjCIvar:
|
|
case CXIdxEntity_EnumConstant:
|
|
case CXIdxEntity_CXXStaticVariable:
|
|
case CXIdxEntity_Variable:
|
|
case CXIdxEntity_Field: {
|
|
Range loc = cursor.get_spell();
|
|
CheckTypeDependentMemberRefExpr(&loc, cursor, param, db);
|
|
|
|
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;
|
|
Range spell = referenced.get_spell(&referenced_file);
|
|
if (file == referenced_file) {
|
|
var.def.spell = SetUse(db, spell, lex_parent, Role::Definition);
|
|
var.def.extent =
|
|
SetUse(db, referenced.get_extent(), lex_parent, Role::None);
|
|
|
|
// 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.
|
|
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));
|
|
break;
|
|
}
|
|
|
|
case CXIdxEntity_CXXConversionFunction:
|
|
case CXIdxEntity_CXXStaticMethod:
|
|
case CXIdxEntity_CXXInstanceMethod:
|
|
case CXIdxEntity_ObjCInstanceMethod:
|
|
case CXIdxEntity_ObjCClassMethod:
|
|
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?
|
|
Range loc = cursor.get_spell();
|
|
|
|
IndexFunc& called = db->ToFunc(HashUsr(ref->referencedEntity->USR));
|
|
|
|
std::string_view short_name = called.def.Name(false);
|
|
// 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.
|
|
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)));
|
|
|
|
// 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
|
|
// ranges. See the comment above for the CXIdxEntity_Field case.
|
|
if (is_implicit)
|
|
loc = cursor.get_extent();
|
|
else
|
|
CheckTypeDependentMemberRefExpr(&loc, cursor, param, db);
|
|
|
|
OnIndexReference_Function(
|
|
db, loc, ref->container->cursor, called,
|
|
GetRole(ref, Role::Call) |
|
|
(is_implicit ? Role::Implicit : Role::None));
|
|
|
|
// 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;
|
|
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.
|
|
std::optional<ClangCursor> opt_found_type = FindType(ref->cursor);
|
|
if (opt_found_type) {
|
|
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()) {
|
|
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.
|
|
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}});
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case CXIdxEntity_ObjCCategory:
|
|
case CXIdxEntity_ObjCProtocol:
|
|
case CXIdxEntity_ObjCClass:
|
|
case CXIdxEntity_Typedef:
|
|
case CXIdxEntity_CXXInterface: // MSVC __interface
|
|
case CXIdxEntity_CXXTypeAlias:
|
|
case CXIdxEntity_Enum:
|
|
case CXIdxEntity_Union:
|
|
case CXIdxEntity_Struct:
|
|
case CXIdxEntity_CXXClass: {
|
|
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);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
std::vector<std::unique_ptr<IndexFile>> ClangIndexer::Index(
|
|
VFS* vfs,
|
|
std::string file,
|
|
const std::vector<std::string>& args,
|
|
const std::vector<FileContents>& file_contents) {
|
|
if (!g_config->index.enabled)
|
|
return {};
|
|
|
|
file = NormalizePath(file);
|
|
|
|
Timer timer("parse", "parse tu");
|
|
timer.startTimer();
|
|
|
|
std::vector<CXUnsavedFile> unsaved_files;
|
|
for (const FileContents& contents : file_contents) {
|
|
CXUnsavedFile unsaved;
|
|
unsaved.Filename = contents.path.c_str();
|
|
unsaved.Contents = contents.content.c_str();
|
|
unsaved.Length = (unsigned long)contents.content.size();
|
|
unsaved_files.push_back(unsaved);
|
|
}
|
|
|
|
std::unique_ptr<ClangTranslationUnit> tu = ClangTranslationUnit::Create(
|
|
&index, file, args, unsaved_files,
|
|
CXTranslationUnit_KeepGoing |
|
|
CXTranslationUnit_DetailedPreprocessingRecord);
|
|
if (!tu)
|
|
return {};
|
|
|
|
timer.stopTimer();
|
|
|
|
return ParseWithTu(vfs, tu.get(), &index, file, args, unsaved_files);
|
|
}
|
|
|
|
std::vector<std::unique_ptr<IndexFile>> ParseWithTu(
|
|
VFS* vfs,
|
|
ClangTranslationUnit* tu,
|
|
ClangIndex* index,
|
|
const std::string& file,
|
|
const std::vector<std::string>& args,
|
|
const std::vector<CXUnsavedFile>& file_contents) {
|
|
IndexerCallbacks callback = {0};
|
|
// Available callbacks:
|
|
// - abortQuery
|
|
// - enteredMainFile
|
|
// - ppIncludedFile
|
|
// - importedASTFile
|
|
// - startedTranslationUnit
|
|
callback.diagnostic = &OnIndexDiagnostic;
|
|
callback.ppIncludedFile = &OnIndexIncludedFile;
|
|
callback.indexDeclaration = &OnIndexDeclaration;
|
|
callback.indexEntityReference = &OnIndexReference;
|
|
|
|
FileConsumer file_consumer(vfs, file);
|
|
IndexParam param(tu, &file_consumer);
|
|
for (const CXUnsavedFile& contents : file_contents) {
|
|
param.file_contents[contents.Filename] = FileContents(
|
|
contents.Filename, std::string(contents.Contents, contents.Length));
|
|
}
|
|
|
|
CXFile cx_file = clang_getFile(tu->cx_tu, file.c_str());
|
|
param.primary_file = ConsumeFile(¶m, cx_file);
|
|
|
|
CXIndexAction index_action = clang_IndexAction_create(index->cx_index);
|
|
|
|
// |index_result| is a CXErrorCode instance.
|
|
int index_result = clang_indexTranslationUnit(
|
|
index_action, ¶m, &callback, sizeof(IndexerCallbacks),
|
|
CXIndexOpt_IndexFunctionLocalSymbols |
|
|
CXIndexOpt_SkipParsedBodiesInSession |
|
|
CXIndexOpt_IndexImplicitTemplateInstantiations,
|
|
tu->cx_tu);
|
|
if (index_result != CXError_Success) {
|
|
LOG_S(ERROR) << "Indexing " << file
|
|
<< " failed with errno=" << index_result;
|
|
return {};
|
|
}
|
|
clang_IndexAction_dispose(index_action);
|
|
|
|
ClangCursor(clang_getTranslationUnitCursor(tu->cx_tu))
|
|
.VisitChildren(&VisitMacroDefinitionAndExpansions, ¶m);
|
|
|
|
std::unordered_map<std::string, int> inc_to_line;
|
|
// TODO
|
|
if (param.primary_file)
|
|
for (auto& inc : param.primary_file->includes)
|
|
inc_to_line[inc.resolved_path] = inc.line;
|
|
|
|
auto result = param.file_consumer->TakeLocalState();
|
|
for (std::unique_ptr<IndexFile>& entry : result) {
|
|
entry->import_file = file;
|
|
entry->args = args;
|
|
for (auto& it : entry->usr2func) {
|
|
// e.g. declaration + out-of-line definition
|
|
Uniquify(it.second.derived);
|
|
Uniquify(it.second.uses);
|
|
}
|
|
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);
|
|
|
|
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 =
|
|
lsRange{lsPosition{line, 10}, lsPosition{line, 10}};
|
|
param.primary_file->diagnostics_.push_back(ls_diagnostic);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Update file contents and modification time.
|
|
entry->last_write_time = param.file2write_time[entry->path];
|
|
|
|
// 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];
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
// |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);
|
|
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);
|
|
Reflect(visitor, value.kind);
|
|
Reflect(visitor, value.role);
|
|
}
|
|
}
|