2016-02-13 07:10:59 +08:00
|
|
|
//===- IndexingContext.cpp - Indexing context data ------------------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "IndexingContext.h"
|
|
|
|
#include "clang/Index/IndexDataConsumer.h"
|
|
|
|
#include "clang/AST/ASTContext.h"
|
|
|
|
#include "clang/AST/DeclTemplate.h"
|
|
|
|
#include "clang/AST/DeclObjC.h"
|
|
|
|
#include "clang/Basic/SourceManager.h"
|
|
|
|
|
|
|
|
using namespace clang;
|
|
|
|
using namespace index;
|
|
|
|
|
2017-04-21 13:42:46 +08:00
|
|
|
static bool isGeneratedDecl(const Decl *D) {
|
|
|
|
if (auto *attr = D->getAttr<ExternalSourceSymbolAttr>()) {
|
|
|
|
return attr->getGeneratedDeclaration();
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IndexingContext::shouldIndex(const Decl *D) {
|
|
|
|
return !isGeneratedDecl(D);
|
|
|
|
}
|
|
|
|
|
2017-04-24 22:04:58 +08:00
|
|
|
const LangOptions &IndexingContext::getLangOpts() const {
|
|
|
|
return Ctx->getLangOpts();
|
|
|
|
}
|
|
|
|
|
2016-02-13 07:10:59 +08:00
|
|
|
bool IndexingContext::shouldIndexFunctionLocalSymbols() const {
|
|
|
|
return IndexOpts.IndexFunctionLocals;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IndexingContext::handleDecl(const Decl *D,
|
|
|
|
SymbolRoleSet Roles,
|
|
|
|
ArrayRef<SymbolRelation> Relations) {
|
2017-02-17 12:49:41 +08:00
|
|
|
return handleDecl(D, D->getLocation(), Roles, Relations);
|
2016-02-13 07:10:59 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
bool IndexingContext::handleDecl(const Decl *D, SourceLocation Loc,
|
|
|
|
SymbolRoleSet Roles,
|
|
|
|
ArrayRef<SymbolRelation> Relations,
|
|
|
|
const DeclContext *DC) {
|
|
|
|
if (!DC)
|
|
|
|
DC = D->getDeclContext();
|
2017-02-17 12:49:41 +08:00
|
|
|
|
|
|
|
const Decl *OrigD = D;
|
|
|
|
if (isa<ObjCPropertyImplDecl>(D)) {
|
|
|
|
D = cast<ObjCPropertyImplDecl>(D)->getPropertyDecl();
|
|
|
|
}
|
2016-02-13 07:10:59 +08:00
|
|
|
return handleDeclOccurrence(D, Loc, /*IsRef=*/false, cast<Decl>(DC),
|
|
|
|
Roles, Relations,
|
2017-02-17 12:49:41 +08:00
|
|
|
nullptr, OrigD, DC);
|
2016-02-13 07:10:59 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
bool IndexingContext::handleReference(const NamedDecl *D, SourceLocation Loc,
|
|
|
|
const NamedDecl *Parent,
|
|
|
|
const DeclContext *DC,
|
|
|
|
SymbolRoleSet Roles,
|
|
|
|
ArrayRef<SymbolRelation> Relations,
|
|
|
|
const Expr *RefE,
|
|
|
|
const Decl *RefD) {
|
2017-02-26 13:37:56 +08:00
|
|
|
if (!shouldIndexFunctionLocalSymbols() && isFunctionLocalSymbol(D))
|
2016-02-13 07:10:59 +08:00
|
|
|
return true;
|
|
|
|
|
|
|
|
if (isa<NonTypeTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return handleDeclOccurrence(D, Loc, /*IsRef=*/true, Parent, Roles, Relations,
|
|
|
|
RefE, RefD, DC);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IndexingContext::importedModule(const ImportDecl *ImportD) {
|
2016-02-29 15:56:07 +08:00
|
|
|
SourceLocation Loc;
|
|
|
|
auto IdLocs = ImportD->getIdentifierLocs();
|
|
|
|
if (!IdLocs.empty())
|
|
|
|
Loc = IdLocs.front();
|
|
|
|
else
|
|
|
|
Loc = ImportD->getLocation();
|
2016-02-13 07:10:59 +08:00
|
|
|
SourceManager &SM = Ctx->getSourceManager();
|
|
|
|
Loc = SM.getFileLoc(Loc);
|
|
|
|
if (Loc.isInvalid())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
FileID FID;
|
|
|
|
unsigned Offset;
|
|
|
|
std::tie(FID, Offset) = SM.getDecomposedLoc(Loc);
|
|
|
|
if (FID.isInvalid())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
bool Invalid = false;
|
|
|
|
const SrcMgr::SLocEntry &SEntry = SM.getSLocEntry(FID, &Invalid);
|
|
|
|
if (Invalid || !SEntry.isFile())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (SEntry.getFile().getFileCharacteristic() != SrcMgr::C_User) {
|
|
|
|
switch (IndexOpts.SystemSymbolFilter) {
|
|
|
|
case IndexingOptions::SystemSymbolFilterKind::None:
|
|
|
|
return true;
|
2016-07-15 02:51:55 +08:00
|
|
|
case IndexingOptions::SystemSymbolFilterKind::DeclarationsOnly:
|
2016-02-13 07:10:59 +08:00
|
|
|
case IndexingOptions::SystemSymbolFilterKind::All:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-07-15 02:51:55 +08:00
|
|
|
SymbolRoleSet Roles = (unsigned)SymbolRole::Declaration;
|
2016-02-13 07:10:59 +08:00
|
|
|
if (ImportD->isImplicit())
|
|
|
|
Roles |= (unsigned)SymbolRole::Implicit;
|
|
|
|
|
|
|
|
return DataConsumer.handleModuleOccurence(ImportD, Roles, FID, Offset);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IndexingContext::isTemplateImplicitInstantiation(const Decl *D) {
|
|
|
|
TemplateSpecializationKind TKind = TSK_Undeclared;
|
|
|
|
if (const ClassTemplateSpecializationDecl *
|
|
|
|
SD = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
|
|
|
|
TKind = SD->getSpecializationKind();
|
2016-11-08 05:20:15 +08:00
|
|
|
} else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
|
2016-02-13 07:10:59 +08:00
|
|
|
TKind = FD->getTemplateSpecializationKind();
|
2016-11-08 05:20:15 +08:00
|
|
|
} else if (auto *VD = dyn_cast<VarDecl>(D)) {
|
|
|
|
TKind = VD->getTemplateSpecializationKind();
|
2017-05-24 00:23:28 +08:00
|
|
|
} else if (const auto *RD = dyn_cast<CXXRecordDecl>(D)) {
|
|
|
|
if (RD->getInstantiatedFromMemberClass())
|
|
|
|
TKind = RD->getTemplateSpecializationKind();
|
2017-05-24 00:35:50 +08:00
|
|
|
} else if (const auto *ED = dyn_cast<EnumDecl>(D)) {
|
|
|
|
if (ED->getInstantiatedFromMemberEnum())
|
|
|
|
TKind = ED->getTemplateSpecializationKind();
|
2017-05-24 00:47:01 +08:00
|
|
|
} else if (isa<FieldDecl>(D) || isa<TypedefNameDecl>(D) ||
|
|
|
|
isa<EnumConstantDecl>(D)) {
|
2017-05-24 00:25:06 +08:00
|
|
|
if (const auto *Parent = dyn_cast<Decl>(D->getDeclContext()))
|
|
|
|
return isTemplateImplicitInstantiation(Parent);
|
2016-02-13 07:10:59 +08:00
|
|
|
}
|
|
|
|
switch (TKind) {
|
|
|
|
case TSK_Undeclared:
|
|
|
|
case TSK_ExplicitSpecialization:
|
|
|
|
return false;
|
|
|
|
case TSK_ImplicitInstantiation:
|
|
|
|
case TSK_ExplicitInstantiationDeclaration:
|
|
|
|
case TSK_ExplicitInstantiationDefinition:
|
|
|
|
return true;
|
|
|
|
}
|
2016-02-15 08:36:52 +08:00
|
|
|
llvm_unreachable("invalid TemplateSpecializationKind");
|
2016-02-13 07:10:59 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
bool IndexingContext::shouldIgnoreIfImplicit(const Decl *D) {
|
|
|
|
if (isa<ObjCInterfaceDecl>(D))
|
|
|
|
return false;
|
|
|
|
if (isa<ObjCCategoryDecl>(D))
|
|
|
|
return false;
|
|
|
|
if (isa<ObjCIvarDecl>(D))
|
|
|
|
return false;
|
|
|
|
if (isa<ObjCMethodDecl>(D))
|
|
|
|
return false;
|
|
|
|
if (isa<ImportDecl>(D))
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-05-24 00:25:06 +08:00
|
|
|
static const CXXRecordDecl *
|
|
|
|
getDeclContextForTemplateInstationPattern(const Decl *D) {
|
|
|
|
if (const auto *CTSD =
|
|
|
|
dyn_cast<ClassTemplateSpecializationDecl>(D->getDeclContext()))
|
|
|
|
return CTSD->getTemplateInstantiationPattern();
|
|
|
|
else if (const auto *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext()))
|
|
|
|
return RD->getInstantiatedFromMemberClass();
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2016-02-13 07:10:59 +08:00
|
|
|
static const Decl *adjustTemplateImplicitInstantiation(const Decl *D) {
|
|
|
|
if (const ClassTemplateSpecializationDecl *
|
|
|
|
SD = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
|
|
|
|
return SD->getTemplateInstantiationPattern();
|
2016-11-08 05:20:15 +08:00
|
|
|
} else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
|
2016-02-13 07:10:59 +08:00
|
|
|
return FD->getTemplateInstantiationPattern();
|
2016-11-08 05:20:15 +08:00
|
|
|
} else if (auto *VD = dyn_cast<VarDecl>(D)) {
|
|
|
|
return VD->getTemplateInstantiationPattern();
|
2017-05-24 00:23:28 +08:00
|
|
|
} else if (const auto *RD = dyn_cast<CXXRecordDecl>(D)) {
|
|
|
|
return RD->getInstantiatedFromMemberClass();
|
2017-05-24 00:35:50 +08:00
|
|
|
} else if (const auto *ED = dyn_cast<EnumDecl>(D)) {
|
|
|
|
return ED->getInstantiatedFromMemberEnum();
|
2017-05-24 00:27:42 +08:00
|
|
|
} else if (isa<FieldDecl>(D) || isa<TypedefNameDecl>(D)) {
|
|
|
|
const auto *ND = cast<NamedDecl>(D);
|
2017-05-24 00:25:06 +08:00
|
|
|
if (const CXXRecordDecl *Pattern =
|
2017-05-24 00:27:42 +08:00
|
|
|
getDeclContextForTemplateInstationPattern(ND)) {
|
|
|
|
for (const NamedDecl *BaseND : Pattern->lookup(ND->getDeclName())) {
|
|
|
|
if (BaseND->isImplicit())
|
2017-05-15 22:26:22 +08:00
|
|
|
continue;
|
2017-05-24 00:27:42 +08:00
|
|
|
if (BaseND->getKind() == ND->getKind())
|
|
|
|
return BaseND;
|
2017-05-15 22:26:22 +08:00
|
|
|
}
|
|
|
|
}
|
2017-05-24 00:47:01 +08:00
|
|
|
} else if (const auto *ECD = dyn_cast<EnumConstantDecl>(D)) {
|
|
|
|
if (const auto *ED = dyn_cast<EnumDecl>(ECD->getDeclContext())) {
|
|
|
|
if (const EnumDecl *Pattern = ED->getInstantiatedFromMemberEnum()) {
|
|
|
|
for (const NamedDecl *BaseECD : Pattern->lookup(ECD->getDeclName()))
|
|
|
|
return BaseECD;
|
|
|
|
}
|
|
|
|
}
|
2016-02-13 07:10:59 +08:00
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2016-04-01 04:18:22 +08:00
|
|
|
static bool isDeclADefinition(const Decl *D, const DeclContext *ContainerDC, ASTContext &Ctx) {
|
2016-02-13 07:10:59 +08:00
|
|
|
if (auto VD = dyn_cast<VarDecl>(D))
|
|
|
|
return VD->isThisDeclarationADefinition(Ctx);
|
|
|
|
|
|
|
|
if (auto FD = dyn_cast<FunctionDecl>(D))
|
|
|
|
return FD->isThisDeclarationADefinition();
|
|
|
|
|
|
|
|
if (auto TD = dyn_cast<TagDecl>(D))
|
|
|
|
return TD->isThisDeclarationADefinition();
|
|
|
|
|
|
|
|
if (auto MD = dyn_cast<ObjCMethodDecl>(D))
|
2016-04-01 04:18:22 +08:00
|
|
|
return MD->isThisDeclarationADefinition() || isa<ObjCImplDecl>(ContainerDC);
|
2016-02-13 07:10:59 +08:00
|
|
|
|
|
|
|
if (isa<TypedefNameDecl>(D) ||
|
|
|
|
isa<EnumConstantDecl>(D) ||
|
|
|
|
isa<FieldDecl>(D) ||
|
|
|
|
isa<MSPropertyDecl>(D) ||
|
|
|
|
isa<ObjCImplDecl>(D) ||
|
|
|
|
isa<ObjCPropertyImplDecl>(D))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-07-13 06:05:30 +08:00
|
|
|
/// Whether the given NamedDecl should be skipped because it has no name.
|
|
|
|
static bool shouldSkipNamelessDecl(const NamedDecl *ND) {
|
|
|
|
return ND->getDeclName().isEmpty() && !isa<TagDecl>(ND) &&
|
|
|
|
!isa<ObjCCategoryDecl>(ND);
|
|
|
|
}
|
|
|
|
|
2016-02-13 07:10:59 +08:00
|
|
|
static const Decl *adjustParent(const Decl *Parent) {
|
|
|
|
if (!Parent)
|
|
|
|
return nullptr;
|
|
|
|
for (;; Parent = cast<Decl>(Parent->getDeclContext())) {
|
|
|
|
if (isa<TranslationUnitDecl>(Parent))
|
|
|
|
return nullptr;
|
|
|
|
if (isa<LinkageSpecDecl>(Parent) || isa<BlockDecl>(Parent))
|
|
|
|
continue;
|
|
|
|
if (auto NS = dyn_cast<NamespaceDecl>(Parent)) {
|
|
|
|
if (NS->isAnonymousNamespace())
|
|
|
|
continue;
|
|
|
|
} else if (auto RD = dyn_cast<RecordDecl>(Parent)) {
|
|
|
|
if (RD->isAnonymousStructOrUnion())
|
|
|
|
continue;
|
2017-07-13 06:05:30 +08:00
|
|
|
} else if (auto ND = dyn_cast<NamedDecl>(Parent)) {
|
|
|
|
if (shouldSkipNamelessDecl(ND))
|
2016-02-13 07:10:59 +08:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
return Parent;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static const Decl *getCanonicalDecl(const Decl *D) {
|
|
|
|
D = D->getCanonicalDecl();
|
|
|
|
if (auto TD = dyn_cast<TemplateDecl>(D)) {
|
2017-07-18 15:20:53 +08:00
|
|
|
if (auto TTD = TD->getTemplatedDecl()) {
|
|
|
|
D = TTD;
|
|
|
|
assert(D->isCanonicalDecl());
|
|
|
|
}
|
2016-02-13 07:10:59 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return D;
|
|
|
|
}
|
|
|
|
|
2017-03-24 00:34:47 +08:00
|
|
|
static bool shouldReportOccurrenceForSystemDeclOnlyMode(
|
|
|
|
bool IsRef, SymbolRoleSet Roles, ArrayRef<SymbolRelation> Relations) {
|
|
|
|
if (!IsRef)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
auto acceptForRelation = [](SymbolRoleSet roles) -> bool {
|
|
|
|
bool accept = false;
|
|
|
|
applyForEachSymbolRoleInterruptible(roles, [&accept](SymbolRole r) -> bool {
|
|
|
|
switch (r) {
|
|
|
|
case SymbolRole::RelationChildOf:
|
|
|
|
case SymbolRole::RelationBaseOf:
|
|
|
|
case SymbolRole::RelationOverrideOf:
|
|
|
|
case SymbolRole::RelationExtendedBy:
|
|
|
|
case SymbolRole::RelationAccessorOf:
|
|
|
|
case SymbolRole::RelationIBTypeOf:
|
|
|
|
accept = true;
|
|
|
|
return false;
|
|
|
|
case SymbolRole::Declaration:
|
|
|
|
case SymbolRole::Definition:
|
|
|
|
case SymbolRole::Reference:
|
|
|
|
case SymbolRole::Read:
|
|
|
|
case SymbolRole::Write:
|
|
|
|
case SymbolRole::Call:
|
|
|
|
case SymbolRole::Dynamic:
|
|
|
|
case SymbolRole::AddressOf:
|
|
|
|
case SymbolRole::Implicit:
|
|
|
|
case SymbolRole::RelationReceivedBy:
|
|
|
|
case SymbolRole::RelationCalledBy:
|
|
|
|
case SymbolRole::RelationContainedBy:
|
2017-04-20 18:43:22 +08:00
|
|
|
case SymbolRole::RelationSpecializationOf:
|
2017-03-24 00:34:47 +08:00
|
|
|
return true;
|
|
|
|
}
|
2017-03-25 00:59:14 +08:00
|
|
|
llvm_unreachable("Unsupported SymbolRole value!");
|
2017-03-24 00:34:47 +08:00
|
|
|
});
|
|
|
|
return accept;
|
|
|
|
};
|
|
|
|
|
|
|
|
for (auto &Rel : Relations) {
|
|
|
|
if (acceptForRelation(Rel.Roles))
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-02-13 07:10:59 +08:00
|
|
|
bool IndexingContext::handleDeclOccurrence(const Decl *D, SourceLocation Loc,
|
|
|
|
bool IsRef, const Decl *Parent,
|
|
|
|
SymbolRoleSet Roles,
|
|
|
|
ArrayRef<SymbolRelation> Relations,
|
|
|
|
const Expr *OrigE,
|
|
|
|
const Decl *OrigD,
|
|
|
|
const DeclContext *ContainerDC) {
|
|
|
|
if (D->isImplicit() && !isa<ObjCMethodDecl>(D))
|
|
|
|
return true;
|
2017-07-13 06:05:30 +08:00
|
|
|
if (!isa<NamedDecl>(D) || shouldSkipNamelessDecl(cast<NamedDecl>(D)))
|
2016-02-13 07:10:59 +08:00
|
|
|
return true;
|
|
|
|
|
|
|
|
SourceManager &SM = Ctx->getSourceManager();
|
|
|
|
Loc = SM.getFileLoc(Loc);
|
|
|
|
if (Loc.isInvalid())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
FileID FID;
|
|
|
|
unsigned Offset;
|
|
|
|
std::tie(FID, Offset) = SM.getDecomposedLoc(Loc);
|
|
|
|
if (FID.isInvalid())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
bool Invalid = false;
|
|
|
|
const SrcMgr::SLocEntry &SEntry = SM.getSLocEntry(FID, &Invalid);
|
|
|
|
if (Invalid || !SEntry.isFile())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (SEntry.getFile().getFileCharacteristic() != SrcMgr::C_User) {
|
|
|
|
switch (IndexOpts.SystemSymbolFilter) {
|
|
|
|
case IndexingOptions::SystemSymbolFilterKind::None:
|
|
|
|
return true;
|
|
|
|
case IndexingOptions::SystemSymbolFilterKind::DeclarationsOnly:
|
2017-03-24 00:34:47 +08:00
|
|
|
if (!shouldReportOccurrenceForSystemDeclOnlyMode(IsRef, Roles, Relations))
|
2016-02-13 07:10:59 +08:00
|
|
|
return true;
|
|
|
|
break;
|
|
|
|
case IndexingOptions::SystemSymbolFilterKind::All:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (isTemplateImplicitInstantiation(D)) {
|
|
|
|
if (!IsRef)
|
|
|
|
return true;
|
|
|
|
D = adjustTemplateImplicitInstantiation(D);
|
|
|
|
if (!D)
|
|
|
|
return true;
|
|
|
|
assert(!isTemplateImplicitInstantiation(D));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!OrigD)
|
|
|
|
OrigD = D;
|
|
|
|
|
|
|
|
if (IsRef)
|
|
|
|
Roles |= (unsigned)SymbolRole::Reference;
|
2017-02-17 12:49:41 +08:00
|
|
|
else if (isDeclADefinition(OrigD, ContainerDC, *Ctx))
|
2016-02-13 07:10:59 +08:00
|
|
|
Roles |= (unsigned)SymbolRole::Definition;
|
|
|
|
else
|
|
|
|
Roles |= (unsigned)SymbolRole::Declaration;
|
|
|
|
|
|
|
|
D = getCanonicalDecl(D);
|
|
|
|
Parent = adjustParent(Parent);
|
|
|
|
if (Parent)
|
|
|
|
Parent = getCanonicalDecl(Parent);
|
|
|
|
|
|
|
|
SmallVector<SymbolRelation, 6> FinalRelations;
|
|
|
|
FinalRelations.reserve(Relations.size()+1);
|
|
|
|
|
|
|
|
auto addRelation = [&](SymbolRelation Rel) {
|
|
|
|
auto It = std::find_if(FinalRelations.begin(), FinalRelations.end(),
|
|
|
|
[&](SymbolRelation Elem)->bool {
|
|
|
|
return Elem.RelatedSymbol == Rel.RelatedSymbol;
|
|
|
|
});
|
|
|
|
if (It != FinalRelations.end()) {
|
|
|
|
It->Roles |= Rel.Roles;
|
|
|
|
} else {
|
|
|
|
FinalRelations.push_back(Rel);
|
|
|
|
}
|
|
|
|
Roles |= Rel.Roles;
|
|
|
|
};
|
|
|
|
|
2017-01-12 04:51:10 +08:00
|
|
|
if (Parent) {
|
2017-02-26 13:37:56 +08:00
|
|
|
if (IsRef || (!isa<ParmVarDecl>(D) && isFunctionLocalSymbol(D))) {
|
2017-01-12 05:01:07 +08:00
|
|
|
addRelation(SymbolRelation{
|
|
|
|
(unsigned)SymbolRole::RelationContainedBy,
|
|
|
|
Parent
|
|
|
|
});
|
2017-02-26 13:37:56 +08:00
|
|
|
} else {
|
2017-01-12 05:01:07 +08:00
|
|
|
addRelation(SymbolRelation{
|
|
|
|
(unsigned)SymbolRole::RelationChildOf,
|
|
|
|
Parent
|
|
|
|
});
|
2017-01-12 04:51:10 +08:00
|
|
|
}
|
2016-02-13 07:10:59 +08:00
|
|
|
}
|
2017-01-12 04:51:10 +08:00
|
|
|
|
2016-02-13 07:10:59 +08:00
|
|
|
for (auto &Rel : Relations) {
|
|
|
|
addRelation(SymbolRelation(Rel.Roles,
|
|
|
|
Rel.RelatedSymbol->getCanonicalDecl()));
|
|
|
|
}
|
|
|
|
|
|
|
|
IndexDataConsumer::ASTNodeInfo Node{ OrigE, OrigD, Parent, ContainerDC };
|
|
|
|
return DataConsumer.handleDeclOccurence(D, Roles, FinalRelations, FID, Offset,
|
|
|
|
Node);
|
|
|
|
}
|