mirror of
https://github.com/llvm/llvm-project.git
synced 2025-04-29 19:46:06 +00:00
75e16fd2c6
Add support for concepts and requires expression in the clang index. Genarate USRs for concepts. Also change how `RecursiveASTVisitor` handles return type requirement in requires expressions. The new code unpacks the synthetic template parameter list used for storing the actual expression. This simplifies implementation of the indexing. No code seems to depend on the original traversal anyway and the synthesized template parameter list is easily accessible from inside the requires expression if needed. Add tests in the clangd codebase. Fixes https://github.com/clangd/clangd/issues/1103. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D124441
818 lines
31 KiB
C++
818 lines
31 KiB
C++
//===- IndexDecl.cpp - Indexing declarations ------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "IndexingContext.h"
|
|
#include "clang/AST/ASTConcept.h"
|
|
#include "clang/AST/Attr.h"
|
|
#include "clang/AST/Decl.h"
|
|
#include "clang/AST/DeclTemplate.h"
|
|
#include "clang/AST/DeclVisitor.h"
|
|
#include "clang/Index/IndexDataConsumer.h"
|
|
#include "clang/Index/IndexSymbol.h"
|
|
|
|
using namespace clang;
|
|
using namespace index;
|
|
|
|
#define TRY_DECL(D,CALL_EXPR) \
|
|
do { \
|
|
if (!IndexCtx.shouldIndex(D)) return true; \
|
|
if (!CALL_EXPR) \
|
|
return false; \
|
|
} while (0)
|
|
|
|
#define TRY_TO(CALL_EXPR) \
|
|
do { \
|
|
if (!CALL_EXPR) \
|
|
return false; \
|
|
} while (0)
|
|
|
|
namespace {
|
|
|
|
class IndexingDeclVisitor : public ConstDeclVisitor<IndexingDeclVisitor, bool> {
|
|
IndexingContext &IndexCtx;
|
|
|
|
public:
|
|
explicit IndexingDeclVisitor(IndexingContext &indexCtx)
|
|
: IndexCtx(indexCtx) { }
|
|
|
|
bool Handled = true;
|
|
|
|
bool VisitDecl(const Decl *D) {
|
|
Handled = false;
|
|
return true;
|
|
}
|
|
|
|
void handleTemplateArgumentLoc(const TemplateArgumentLoc &TALoc,
|
|
const NamedDecl *Parent,
|
|
const DeclContext *DC) {
|
|
const TemplateArgumentLocInfo &LocInfo = TALoc.getLocInfo();
|
|
switch (TALoc.getArgument().getKind()) {
|
|
case TemplateArgument::Expression:
|
|
IndexCtx.indexBody(LocInfo.getAsExpr(), Parent, DC);
|
|
break;
|
|
case TemplateArgument::Type:
|
|
IndexCtx.indexTypeSourceInfo(LocInfo.getAsTypeSourceInfo(), Parent, DC);
|
|
break;
|
|
case TemplateArgument::Template:
|
|
case TemplateArgument::TemplateExpansion:
|
|
IndexCtx.indexNestedNameSpecifierLoc(TALoc.getTemplateQualifierLoc(),
|
|
Parent, DC);
|
|
if (const TemplateDecl *TD = TALoc.getArgument()
|
|
.getAsTemplateOrTemplatePattern()
|
|
.getAsTemplateDecl()) {
|
|
if (const NamedDecl *TTD = TD->getTemplatedDecl())
|
|
IndexCtx.handleReference(TTD, TALoc.getTemplateNameLoc(), Parent, DC);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
/// Returns true if the given method has been defined explicitly by the
|
|
/// user.
|
|
static bool hasUserDefined(const ObjCMethodDecl *D,
|
|
const ObjCImplDecl *Container) {
|
|
const ObjCMethodDecl *MD = Container->getMethod(D->getSelector(),
|
|
D->isInstanceMethod());
|
|
return MD && !MD->isImplicit() && MD->isThisDeclarationADefinition() &&
|
|
!MD->isSynthesizedAccessorStub();
|
|
}
|
|
|
|
|
|
void handleDeclarator(const DeclaratorDecl *D,
|
|
const NamedDecl *Parent = nullptr,
|
|
bool isIBType = false) {
|
|
if (!Parent) Parent = D;
|
|
|
|
IndexCtx.indexTypeSourceInfo(D->getTypeSourceInfo(), Parent,
|
|
Parent->getLexicalDeclContext(),
|
|
/*isBase=*/false, isIBType);
|
|
IndexCtx.indexNestedNameSpecifierLoc(D->getQualifierLoc(), Parent);
|
|
auto IndexDefaultParmeterArgument = [&](const ParmVarDecl *Parm,
|
|
const NamedDecl *Parent) {
|
|
if (Parm->hasDefaultArg() && !Parm->hasUninstantiatedDefaultArg() &&
|
|
!Parm->hasUnparsedDefaultArg())
|
|
IndexCtx.indexBody(Parm->getDefaultArg(), Parent);
|
|
};
|
|
if (IndexCtx.shouldIndexFunctionLocalSymbols()) {
|
|
if (const ParmVarDecl *Parm = dyn_cast<ParmVarDecl>(D)) {
|
|
auto *DC = Parm->getDeclContext();
|
|
if (auto *FD = dyn_cast<FunctionDecl>(DC)) {
|
|
if (IndexCtx.shouldIndexParametersInDeclarations() ||
|
|
FD->isThisDeclarationADefinition())
|
|
IndexCtx.handleDecl(Parm);
|
|
} else if (auto *MD = dyn_cast<ObjCMethodDecl>(DC)) {
|
|
if (MD->isThisDeclarationADefinition())
|
|
IndexCtx.handleDecl(Parm);
|
|
} else {
|
|
IndexCtx.handleDecl(Parm);
|
|
}
|
|
} else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
|
|
if (IndexCtx.shouldIndexParametersInDeclarations() ||
|
|
FD->isThisDeclarationADefinition()) {
|
|
for (const auto *PI : FD->parameters()) {
|
|
IndexDefaultParmeterArgument(PI, D);
|
|
IndexCtx.handleDecl(PI);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// Index the default parameter value for function definitions.
|
|
if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
|
|
if (FD->isThisDeclarationADefinition()) {
|
|
for (const auto *PV : FD->parameters()) {
|
|
IndexDefaultParmeterArgument(PV, D);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (auto *C = D->getTrailingRequiresClause())
|
|
IndexCtx.indexBody(C, Parent);
|
|
}
|
|
|
|
bool handleObjCMethod(const ObjCMethodDecl *D,
|
|
const ObjCPropertyDecl *AssociatedProp = nullptr) {
|
|
SmallVector<SymbolRelation, 4> Relations;
|
|
SmallVector<const ObjCMethodDecl*, 4> Overriden;
|
|
|
|
D->getOverriddenMethods(Overriden);
|
|
for(auto overridden: Overriden) {
|
|
Relations.emplace_back((unsigned) SymbolRole::RelationOverrideOf,
|
|
overridden);
|
|
}
|
|
if (AssociatedProp)
|
|
Relations.emplace_back((unsigned)SymbolRole::RelationAccessorOf,
|
|
AssociatedProp);
|
|
|
|
// getLocation() returns beginning token of a method declaration, but for
|
|
// indexing purposes we want to point to the base name.
|
|
SourceLocation MethodLoc = D->getSelectorStartLoc();
|
|
if (MethodLoc.isInvalid())
|
|
MethodLoc = D->getLocation();
|
|
|
|
SourceLocation AttrLoc;
|
|
|
|
// check for (getter=/setter=)
|
|
if (AssociatedProp) {
|
|
bool isGetter = !D->param_size();
|
|
AttrLoc = isGetter ?
|
|
AssociatedProp->getGetterNameLoc():
|
|
AssociatedProp->getSetterNameLoc();
|
|
}
|
|
|
|
SymbolRoleSet Roles = (SymbolRoleSet)SymbolRole::Dynamic;
|
|
if (D->isImplicit()) {
|
|
if (AttrLoc.isValid()) {
|
|
MethodLoc = AttrLoc;
|
|
} else {
|
|
Roles |= (SymbolRoleSet)SymbolRole::Implicit;
|
|
}
|
|
} else if (AttrLoc.isValid()) {
|
|
IndexCtx.handleReference(D, AttrLoc, cast<NamedDecl>(D->getDeclContext()),
|
|
D->getDeclContext(), 0);
|
|
}
|
|
|
|
TRY_DECL(D, IndexCtx.handleDecl(D, MethodLoc, Roles, Relations));
|
|
IndexCtx.indexTypeSourceInfo(D->getReturnTypeSourceInfo(), D);
|
|
bool hasIBActionAndFirst = D->hasAttr<IBActionAttr>();
|
|
for (const auto *I : D->parameters()) {
|
|
handleDeclarator(I, D, /*isIBType=*/hasIBActionAndFirst);
|
|
hasIBActionAndFirst = false;
|
|
}
|
|
|
|
if (D->isThisDeclarationADefinition()) {
|
|
const Stmt *Body = D->getBody();
|
|
if (Body) {
|
|
IndexCtx.indexBody(Body, D, D);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/// Gather the declarations which the given declaration \D overrides in a
|
|
/// pseudo-override manner.
|
|
///
|
|
/// Pseudo-overrides occur when a class template specialization declares
|
|
/// a declaration that has the same name as a similar declaration in the
|
|
/// non-specialized template.
|
|
void
|
|
gatherTemplatePseudoOverrides(const NamedDecl *D,
|
|
SmallVectorImpl<SymbolRelation> &Relations) {
|
|
if (!IndexCtx.getLangOpts().CPlusPlus)
|
|
return;
|
|
const auto *CTSD =
|
|
dyn_cast<ClassTemplateSpecializationDecl>(D->getLexicalDeclContext());
|
|
if (!CTSD)
|
|
return;
|
|
llvm::PointerUnion<ClassTemplateDecl *,
|
|
ClassTemplatePartialSpecializationDecl *>
|
|
Template = CTSD->getSpecializedTemplateOrPartial();
|
|
if (const auto *CTD = Template.dyn_cast<ClassTemplateDecl *>()) {
|
|
const CXXRecordDecl *Pattern = CTD->getTemplatedDecl();
|
|
bool TypeOverride = isa<TypeDecl>(D);
|
|
for (const NamedDecl *ND : Pattern->lookup(D->getDeclName())) {
|
|
if (const auto *CTD = dyn_cast<ClassTemplateDecl>(ND))
|
|
ND = CTD->getTemplatedDecl();
|
|
if (ND->isImplicit())
|
|
continue;
|
|
// Types can override other types.
|
|
if (!TypeOverride) {
|
|
if (ND->getKind() != D->getKind())
|
|
continue;
|
|
} else if (!isa<TypeDecl>(ND))
|
|
continue;
|
|
if (const auto *FD = dyn_cast<FunctionDecl>(ND)) {
|
|
const auto *DFD = cast<FunctionDecl>(D);
|
|
// Function overrides are approximated using the number of parameters.
|
|
if (FD->getStorageClass() != DFD->getStorageClass() ||
|
|
FD->getNumParams() != DFD->getNumParams())
|
|
continue;
|
|
}
|
|
Relations.emplace_back(
|
|
SymbolRoleSet(SymbolRole::RelationSpecializationOf), ND);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool VisitFunctionDecl(const FunctionDecl *D) {
|
|
SymbolRoleSet Roles{};
|
|
SmallVector<SymbolRelation, 4> Relations;
|
|
if (auto *CXXMD = dyn_cast<CXXMethodDecl>(D)) {
|
|
if (CXXMD->isVirtual())
|
|
Roles |= (unsigned)SymbolRole::Dynamic;
|
|
for (const CXXMethodDecl *O : CXXMD->overridden_methods()) {
|
|
Relations.emplace_back((unsigned)SymbolRole::RelationOverrideOf, O);
|
|
}
|
|
}
|
|
gatherTemplatePseudoOverrides(D, Relations);
|
|
if (const auto *Base = D->getPrimaryTemplate())
|
|
Relations.push_back(
|
|
SymbolRelation(SymbolRoleSet(SymbolRole::RelationSpecializationOf),
|
|
Base->getTemplatedDecl()));
|
|
|
|
TRY_DECL(D, IndexCtx.handleDecl(D, Roles, Relations));
|
|
handleDeclarator(D);
|
|
|
|
if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(D)) {
|
|
IndexCtx.handleReference(Ctor->getParent(), Ctor->getLocation(),
|
|
Ctor->getParent(), Ctor->getDeclContext(),
|
|
(unsigned)SymbolRole::NameReference);
|
|
|
|
// Constructor initializers.
|
|
for (const auto *Init : Ctor->inits()) {
|
|
if (Init->isWritten()) {
|
|
IndexCtx.indexTypeSourceInfo(Init->getTypeSourceInfo(), D);
|
|
if (const FieldDecl *Member = Init->getAnyMember())
|
|
IndexCtx.handleReference(Member, Init->getMemberLocation(), D, D,
|
|
(unsigned)SymbolRole::Write);
|
|
IndexCtx.indexBody(Init->getInit(), D, D);
|
|
}
|
|
}
|
|
} else if (const CXXDestructorDecl *Dtor = dyn_cast<CXXDestructorDecl>(D)) {
|
|
if (auto TypeNameInfo = Dtor->getNameInfo().getNamedTypeInfo()) {
|
|
IndexCtx.handleReference(Dtor->getParent(),
|
|
TypeNameInfo->getTypeLoc().getBeginLoc(),
|
|
Dtor->getParent(), Dtor->getDeclContext(),
|
|
(unsigned)SymbolRole::NameReference);
|
|
}
|
|
} else if (const auto *Guide = dyn_cast<CXXDeductionGuideDecl>(D)) {
|
|
IndexCtx.handleReference(Guide->getDeducedTemplate()->getTemplatedDecl(),
|
|
Guide->getLocation(), Guide,
|
|
Guide->getDeclContext());
|
|
}
|
|
// Template specialization arguments.
|
|
if (const ASTTemplateArgumentListInfo *TemplateArgInfo =
|
|
D->getTemplateSpecializationArgsAsWritten()) {
|
|
for (const auto &Arg : TemplateArgInfo->arguments())
|
|
handleTemplateArgumentLoc(Arg, D, D->getLexicalDeclContext());
|
|
}
|
|
|
|
if (D->isThisDeclarationADefinition()) {
|
|
const Stmt *Body = D->getBody();
|
|
if (Body) {
|
|
IndexCtx.indexBody(Body, D, D);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool VisitVarDecl(const VarDecl *D) {
|
|
SmallVector<SymbolRelation, 4> Relations;
|
|
gatherTemplatePseudoOverrides(D, Relations);
|
|
TRY_DECL(D, IndexCtx.handleDecl(D, SymbolRoleSet(), Relations));
|
|
handleDeclarator(D);
|
|
IndexCtx.indexBody(D->getInit(), D);
|
|
return true;
|
|
}
|
|
|
|
bool VisitDecompositionDecl(const DecompositionDecl *D) {
|
|
for (const auto *Binding : D->bindings())
|
|
TRY_DECL(Binding, IndexCtx.handleDecl(Binding));
|
|
return Base::VisitDecompositionDecl(D);
|
|
}
|
|
|
|
bool VisitFieldDecl(const FieldDecl *D) {
|
|
SmallVector<SymbolRelation, 4> Relations;
|
|
gatherTemplatePseudoOverrides(D, Relations);
|
|
TRY_DECL(D, IndexCtx.handleDecl(D, SymbolRoleSet(), Relations));
|
|
handleDeclarator(D);
|
|
if (D->isBitField())
|
|
IndexCtx.indexBody(D->getBitWidth(), D);
|
|
else if (D->hasInClassInitializer())
|
|
IndexCtx.indexBody(D->getInClassInitializer(), D);
|
|
return true;
|
|
}
|
|
|
|
bool VisitObjCIvarDecl(const ObjCIvarDecl *D) {
|
|
if (D->getSynthesize()) {
|
|
// handled in VisitObjCPropertyImplDecl
|
|
return true;
|
|
}
|
|
TRY_DECL(D, IndexCtx.handleDecl(D));
|
|
handleDeclarator(D);
|
|
return true;
|
|
}
|
|
|
|
bool VisitMSPropertyDecl(const MSPropertyDecl *D) {
|
|
TRY_DECL(D, IndexCtx.handleDecl(D));
|
|
handleDeclarator(D);
|
|
return true;
|
|
}
|
|
|
|
bool VisitEnumConstantDecl(const EnumConstantDecl *D) {
|
|
TRY_DECL(D, IndexCtx.handleDecl(D));
|
|
IndexCtx.indexBody(D->getInitExpr(), D);
|
|
return true;
|
|
}
|
|
|
|
bool VisitTypedefNameDecl(const TypedefNameDecl *D) {
|
|
if (!D->isTransparentTag()) {
|
|
SmallVector<SymbolRelation, 4> Relations;
|
|
gatherTemplatePseudoOverrides(D, Relations);
|
|
TRY_DECL(D, IndexCtx.handleDecl(D, SymbolRoleSet(), Relations));
|
|
IndexCtx.indexTypeSourceInfo(D->getTypeSourceInfo(), D);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool VisitTagDecl(const TagDecl *D) {
|
|
// Non-free standing tags are handled in indexTypeSourceInfo.
|
|
if (D->isFreeStanding()) {
|
|
if (D->isThisDeclarationADefinition()) {
|
|
SmallVector<SymbolRelation, 4> Relations;
|
|
gatherTemplatePseudoOverrides(D, Relations);
|
|
IndexCtx.indexTagDecl(D, Relations);
|
|
} else {
|
|
SmallVector<SymbolRelation, 1> Relations;
|
|
gatherTemplatePseudoOverrides(D, Relations);
|
|
return IndexCtx.handleDecl(D, D->getLocation(), SymbolRoleSet(),
|
|
Relations, D->getLexicalDeclContext());
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool VisitEnumDecl(const EnumDecl *ED) {
|
|
TRY_TO(VisitTagDecl(ED));
|
|
// Indexing for enumdecl itself is handled inside TagDecl, we just want to
|
|
// visit integer-base here, which is different than other TagDecl bases.
|
|
if (auto *TSI = ED->getIntegerTypeSourceInfo())
|
|
IndexCtx.indexTypeSourceInfo(TSI, ED, ED, /*isBase=*/true);
|
|
return true;
|
|
}
|
|
|
|
bool handleReferencedProtocols(const ObjCProtocolList &ProtList,
|
|
const ObjCContainerDecl *ContD,
|
|
SourceLocation SuperLoc) {
|
|
ObjCInterfaceDecl::protocol_loc_iterator LI = ProtList.loc_begin();
|
|
for (ObjCInterfaceDecl::protocol_iterator
|
|
I = ProtList.begin(), E = ProtList.end(); I != E; ++I, ++LI) {
|
|
SourceLocation Loc = *LI;
|
|
ObjCProtocolDecl *PD = *I;
|
|
SymbolRoleSet roles{};
|
|
if (Loc == SuperLoc)
|
|
roles |= (SymbolRoleSet)SymbolRole::Implicit;
|
|
TRY_TO(IndexCtx.handleReference(PD, Loc, ContD, ContD, roles,
|
|
SymbolRelation{(unsigned)SymbolRole::RelationBaseOf, ContD}));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D) {
|
|
if (D->isThisDeclarationADefinition()) {
|
|
TRY_DECL(D, IndexCtx.handleDecl(D));
|
|
SourceLocation SuperLoc = D->getSuperClassLoc();
|
|
if (auto *SuperD = D->getSuperClass()) {
|
|
bool hasSuperTypedef = false;
|
|
if (auto *TInfo = D->getSuperClassTInfo()) {
|
|
if (auto *TT = TInfo->getType()->getAs<TypedefType>()) {
|
|
if (auto *TD = TT->getDecl()) {
|
|
hasSuperTypedef = true;
|
|
TRY_TO(IndexCtx.handleReference(TD, SuperLoc, D, D,
|
|
SymbolRoleSet()));
|
|
}
|
|
}
|
|
}
|
|
SymbolRoleSet superRoles{};
|
|
if (hasSuperTypedef)
|
|
superRoles |= (SymbolRoleSet)SymbolRole::Implicit;
|
|
TRY_TO(IndexCtx.handleReference(SuperD, SuperLoc, D, D, superRoles,
|
|
SymbolRelation{(unsigned)SymbolRole::RelationBaseOf, D}));
|
|
}
|
|
TRY_TO(handleReferencedProtocols(D->getReferencedProtocols(), D,
|
|
SuperLoc));
|
|
TRY_TO(IndexCtx.indexDeclContext(D));
|
|
} else {
|
|
return IndexCtx.handleReference(D, D->getLocation(), nullptr,
|
|
D->getDeclContext(), SymbolRoleSet());
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool VisitObjCProtocolDecl(const ObjCProtocolDecl *D) {
|
|
if (D->isThisDeclarationADefinition()) {
|
|
TRY_DECL(D, IndexCtx.handleDecl(D));
|
|
TRY_TO(handleReferencedProtocols(D->getReferencedProtocols(), D,
|
|
/*SuperLoc=*/SourceLocation()));
|
|
TRY_TO(IndexCtx.indexDeclContext(D));
|
|
} else {
|
|
return IndexCtx.handleReference(D, D->getLocation(), nullptr,
|
|
D->getDeclContext(), SymbolRoleSet());
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool VisitObjCImplementationDecl(const ObjCImplementationDecl *D) {
|
|
const ObjCInterfaceDecl *Class = D->getClassInterface();
|
|
if (!Class)
|
|
return true;
|
|
|
|
if (Class->isImplicitInterfaceDecl())
|
|
IndexCtx.handleDecl(Class);
|
|
|
|
TRY_DECL(D, IndexCtx.handleDecl(D));
|
|
|
|
// Visit implicit @synthesize property implementations first as their
|
|
// location is reported at the name of the @implementation block. This
|
|
// serves no purpose other than to simplify the FileCheck-based tests.
|
|
for (const auto *I : D->property_impls()) {
|
|
if (I->getLocation().isInvalid())
|
|
IndexCtx.indexDecl(I);
|
|
}
|
|
for (const auto *I : D->decls()) {
|
|
if (!isa<ObjCPropertyImplDecl>(I) ||
|
|
cast<ObjCPropertyImplDecl>(I)->getLocation().isValid())
|
|
IndexCtx.indexDecl(I);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool VisitObjCCategoryDecl(const ObjCCategoryDecl *D) {
|
|
if (!IndexCtx.shouldIndex(D))
|
|
return true;
|
|
const ObjCInterfaceDecl *C = D->getClassInterface();
|
|
if (!C)
|
|
return true;
|
|
TRY_TO(IndexCtx.handleReference(C, D->getLocation(), D, D, SymbolRoleSet(),
|
|
SymbolRelation{
|
|
(unsigned)SymbolRole::RelationExtendedBy, D
|
|
}));
|
|
SourceLocation CategoryLoc = D->getCategoryNameLoc();
|
|
if (!CategoryLoc.isValid())
|
|
CategoryLoc = D->getLocation();
|
|
TRY_TO(IndexCtx.handleDecl(D, CategoryLoc));
|
|
TRY_TO(handleReferencedProtocols(D->getReferencedProtocols(), D,
|
|
/*SuperLoc=*/SourceLocation()));
|
|
TRY_TO(IndexCtx.indexDeclContext(D));
|
|
return true;
|
|
}
|
|
|
|
bool VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl *D) {
|
|
const ObjCCategoryDecl *Cat = D->getCategoryDecl();
|
|
if (!Cat)
|
|
return true;
|
|
const ObjCInterfaceDecl *C = D->getClassInterface();
|
|
if (C)
|
|
TRY_TO(IndexCtx.handleReference(C, D->getLocation(), D, D,
|
|
SymbolRoleSet()));
|
|
SourceLocation CategoryLoc = D->getCategoryNameLoc();
|
|
if (!CategoryLoc.isValid())
|
|
CategoryLoc = D->getLocation();
|
|
TRY_DECL(D, IndexCtx.handleDecl(D, CategoryLoc));
|
|
IndexCtx.indexDeclContext(D);
|
|
return true;
|
|
}
|
|
|
|
bool VisitObjCMethodDecl(const ObjCMethodDecl *D) {
|
|
// Methods associated with a property, even user-declared ones, are
|
|
// handled when we handle the property.
|
|
if (D->isPropertyAccessor())
|
|
return true;
|
|
|
|
handleObjCMethod(D);
|
|
return true;
|
|
}
|
|
|
|
bool VisitObjCPropertyDecl(const ObjCPropertyDecl *D) {
|
|
if (ObjCMethodDecl *MD = D->getGetterMethodDecl())
|
|
if (MD->getLexicalDeclContext() == D->getLexicalDeclContext())
|
|
handleObjCMethod(MD, D);
|
|
if (ObjCMethodDecl *MD = D->getSetterMethodDecl())
|
|
if (MD->getLexicalDeclContext() == D->getLexicalDeclContext())
|
|
handleObjCMethod(MD, D);
|
|
TRY_DECL(D, IndexCtx.handleDecl(D));
|
|
if (IBOutletCollectionAttr *attr = D->getAttr<IBOutletCollectionAttr>())
|
|
IndexCtx.indexTypeSourceInfo(attr->getInterfaceLoc(), D,
|
|
D->getLexicalDeclContext(), false, true);
|
|
IndexCtx.indexTypeSourceInfo(D->getTypeSourceInfo(), D);
|
|
return true;
|
|
}
|
|
|
|
bool VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D) {
|
|
ObjCPropertyDecl *PD = D->getPropertyDecl();
|
|
auto *Container = cast<ObjCImplDecl>(D->getDeclContext());
|
|
SourceLocation Loc = D->getLocation();
|
|
SymbolRoleSet Roles = 0;
|
|
SmallVector<SymbolRelation, 1> Relations;
|
|
|
|
if (ObjCIvarDecl *ID = D->getPropertyIvarDecl())
|
|
Relations.push_back({(SymbolRoleSet)SymbolRole::RelationAccessorOf, ID});
|
|
if (Loc.isInvalid()) {
|
|
Loc = Container->getLocation();
|
|
Roles |= (SymbolRoleSet)SymbolRole::Implicit;
|
|
}
|
|
TRY_DECL(D, IndexCtx.handleDecl(D, Loc, Roles, Relations));
|
|
|
|
if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic)
|
|
return true;
|
|
|
|
assert(D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize);
|
|
SymbolRoleSet AccessorMethodRoles =
|
|
SymbolRoleSet(SymbolRole::Dynamic) | SymbolRoleSet(SymbolRole::Implicit);
|
|
if (ObjCMethodDecl *MD = PD->getGetterMethodDecl()) {
|
|
if (MD->isPropertyAccessor() && !hasUserDefined(MD, Container))
|
|
IndexCtx.handleDecl(MD, Loc, AccessorMethodRoles, {}, Container);
|
|
}
|
|
if (ObjCMethodDecl *MD = PD->getSetterMethodDecl()) {
|
|
if (MD->isPropertyAccessor() && !hasUserDefined(MD, Container))
|
|
IndexCtx.handleDecl(MD, Loc, AccessorMethodRoles, {}, Container);
|
|
}
|
|
if (ObjCIvarDecl *IvarD = D->getPropertyIvarDecl()) {
|
|
if (IvarD->getSynthesize()) {
|
|
// For synthesized ivars, use the location of its name in the
|
|
// corresponding @synthesize. If there isn't one, use the containing
|
|
// @implementation's location, rather than the property's location,
|
|
// otherwise the header file containing the @interface will have different
|
|
// indexing contents based on whether the @implementation was present or
|
|
// not in the translation unit.
|
|
SymbolRoleSet IvarRoles = 0;
|
|
SourceLocation IvarLoc = D->getPropertyIvarDeclLoc();
|
|
if (D->getLocation().isInvalid()) {
|
|
IvarLoc = Container->getLocation();
|
|
IvarRoles = (SymbolRoleSet)SymbolRole::Implicit;
|
|
} else if (D->getLocation() == IvarLoc) {
|
|
IvarRoles = (SymbolRoleSet)SymbolRole::Implicit;
|
|
}
|
|
TRY_DECL(IvarD, IndexCtx.handleDecl(IvarD, IvarLoc, IvarRoles));
|
|
} else {
|
|
IndexCtx.handleReference(IvarD, D->getPropertyIvarDeclLoc(), nullptr,
|
|
D->getDeclContext(), SymbolRoleSet());
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool VisitNamespaceDecl(const NamespaceDecl *D) {
|
|
TRY_DECL(D, IndexCtx.handleDecl(D));
|
|
IndexCtx.indexDeclContext(D);
|
|
return true;
|
|
}
|
|
|
|
bool VisitNamespaceAliasDecl(const NamespaceAliasDecl *D) {
|
|
TRY_DECL(D, IndexCtx.handleDecl(D));
|
|
IndexCtx.indexNestedNameSpecifierLoc(D->getQualifierLoc(), D);
|
|
IndexCtx.handleReference(D->getAliasedNamespace(), D->getTargetNameLoc(), D,
|
|
D->getLexicalDeclContext());
|
|
return true;
|
|
}
|
|
|
|
bool VisitUsingDecl(const UsingDecl *D) {
|
|
IndexCtx.handleDecl(D);
|
|
|
|
const DeclContext *DC = D->getDeclContext()->getRedeclContext();
|
|
const NamedDecl *Parent = dyn_cast<NamedDecl>(DC);
|
|
IndexCtx.indexNestedNameSpecifierLoc(D->getQualifierLoc(), Parent,
|
|
D->getLexicalDeclContext());
|
|
for (const auto *I : D->shadows()) {
|
|
// Skip unresolved using decls - we already have a decl for the using
|
|
// itself, so there's not much point adding another decl or reference to
|
|
// refer to the same location.
|
|
if (isa<UnresolvedUsingIfExistsDecl>(I->getUnderlyingDecl()))
|
|
continue;
|
|
|
|
IndexCtx.handleReference(I->getUnderlyingDecl(), D->getLocation(), Parent,
|
|
D->getLexicalDeclContext(), SymbolRoleSet());
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool VisitUsingDirectiveDecl(const UsingDirectiveDecl *D) {
|
|
const DeclContext *DC = D->getDeclContext()->getRedeclContext();
|
|
const NamedDecl *Parent = dyn_cast<NamedDecl>(DC);
|
|
|
|
// NNS for the local 'using namespace' directives is visited by the body
|
|
// visitor.
|
|
if (!D->getParentFunctionOrMethod())
|
|
IndexCtx.indexNestedNameSpecifierLoc(D->getQualifierLoc(), Parent,
|
|
D->getLexicalDeclContext());
|
|
|
|
return IndexCtx.handleReference(D->getNominatedNamespaceAsWritten(),
|
|
D->getLocation(), Parent,
|
|
D->getLexicalDeclContext(),
|
|
SymbolRoleSet());
|
|
}
|
|
|
|
bool VisitUnresolvedUsingValueDecl(const UnresolvedUsingValueDecl *D) {
|
|
TRY_DECL(D, IndexCtx.handleDecl(D));
|
|
const DeclContext *DC = D->getDeclContext()->getRedeclContext();
|
|
const NamedDecl *Parent = dyn_cast<NamedDecl>(DC);
|
|
IndexCtx.indexNestedNameSpecifierLoc(D->getQualifierLoc(), Parent,
|
|
D->getLexicalDeclContext());
|
|
return true;
|
|
}
|
|
|
|
bool VisitUnresolvedUsingTypenameDecl(const UnresolvedUsingTypenameDecl *D) {
|
|
TRY_DECL(D, IndexCtx.handleDecl(D));
|
|
const DeclContext *DC = D->getDeclContext()->getRedeclContext();
|
|
const NamedDecl *Parent = dyn_cast<NamedDecl>(DC);
|
|
IndexCtx.indexNestedNameSpecifierLoc(D->getQualifierLoc(), Parent,
|
|
D->getLexicalDeclContext());
|
|
return true;
|
|
}
|
|
|
|
bool VisitClassTemplateSpecializationDecl(const
|
|
ClassTemplateSpecializationDecl *D) {
|
|
// FIXME: Notify subsequent callbacks if info comes from implicit
|
|
// instantiation.
|
|
llvm::PointerUnion<ClassTemplateDecl *,
|
|
ClassTemplatePartialSpecializationDecl *>
|
|
Template = D->getSpecializedTemplateOrPartial();
|
|
const Decl *SpecializationOf =
|
|
Template.is<ClassTemplateDecl *>()
|
|
? (Decl *)Template.get<ClassTemplateDecl *>()
|
|
: Template.get<ClassTemplatePartialSpecializationDecl *>();
|
|
if (!D->isThisDeclarationADefinition())
|
|
IndexCtx.indexNestedNameSpecifierLoc(D->getQualifierLoc(), D);
|
|
IndexCtx.indexTagDecl(
|
|
D, SymbolRelation(SymbolRoleSet(SymbolRole::RelationSpecializationOf),
|
|
SpecializationOf));
|
|
if (TypeSourceInfo *TSI = D->getTypeAsWritten())
|
|
IndexCtx.indexTypeSourceInfo(TSI, /*Parent=*/nullptr,
|
|
D->getLexicalDeclContext());
|
|
return true;
|
|
}
|
|
|
|
static bool shouldIndexTemplateParameterDefaultValue(const NamedDecl *D) {
|
|
// We want to index the template parameters only once when indexing the
|
|
// canonical declaration.
|
|
if (!D)
|
|
return false;
|
|
if (const auto *FD = dyn_cast<FunctionDecl>(D))
|
|
return FD->getCanonicalDecl() == FD;
|
|
else if (const auto *TD = dyn_cast<TagDecl>(D))
|
|
return TD->getCanonicalDecl() == TD;
|
|
else if (const auto *VD = dyn_cast<VarDecl>(D))
|
|
return VD->getCanonicalDecl() == VD;
|
|
return true;
|
|
}
|
|
|
|
void indexTemplateParameters(TemplateParameterList *Params,
|
|
const NamedDecl *Parent) {
|
|
for (const NamedDecl *TP : *Params) {
|
|
if (IndexCtx.shouldIndexTemplateParameters())
|
|
IndexCtx.handleDecl(TP);
|
|
if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(TP)) {
|
|
if (TTP->hasDefaultArgument())
|
|
IndexCtx.indexTypeSourceInfo(TTP->getDefaultArgumentInfo(), Parent);
|
|
if (auto *C = TTP->getTypeConstraint())
|
|
IndexCtx.handleReference(C->getNamedConcept(), C->getConceptNameLoc(),
|
|
Parent, TTP->getLexicalDeclContext());
|
|
} else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(TP)) {
|
|
if (NTTP->hasDefaultArgument())
|
|
IndexCtx.indexBody(NTTP->getDefaultArgument(), Parent);
|
|
} else if (const auto *TTPD = dyn_cast<TemplateTemplateParmDecl>(TP)) {
|
|
if (TTPD->hasDefaultArgument())
|
|
handleTemplateArgumentLoc(TTPD->getDefaultArgument(), Parent,
|
|
TP->getLexicalDeclContext());
|
|
}
|
|
}
|
|
if (auto *R = Params->getRequiresClause())
|
|
IndexCtx.indexBody(R, Parent);
|
|
}
|
|
|
|
bool VisitTemplateDecl(const TemplateDecl *D) {
|
|
const NamedDecl *Parent = D->getTemplatedDecl();
|
|
if (!Parent)
|
|
return true;
|
|
|
|
// Index the default values for the template parameters.
|
|
auto *Params = D->getTemplateParameters();
|
|
if (Params && shouldIndexTemplateParameterDefaultValue(Parent)) {
|
|
indexTemplateParameters(Params, Parent);
|
|
}
|
|
|
|
return Visit(Parent);
|
|
}
|
|
|
|
bool VisitConceptDecl(const ConceptDecl *D) {
|
|
if (auto *Params = D->getTemplateParameters())
|
|
indexTemplateParameters(Params, D);
|
|
if (auto *E = D->getConstraintExpr())
|
|
IndexCtx.indexBody(E, D);
|
|
return IndexCtx.handleDecl(D);
|
|
}
|
|
|
|
bool VisitFriendDecl(const FriendDecl *D) {
|
|
if (auto ND = D->getFriendDecl()) {
|
|
// FIXME: Ignore a class template in a dependent context, these are not
|
|
// linked properly with their redeclarations, ending up with duplicate
|
|
// USRs.
|
|
// See comment "Friend templates are visible in fairly strange ways." in
|
|
// SemaTemplate.cpp which precedes code that prevents the friend template
|
|
// from becoming visible from the enclosing context.
|
|
if (isa<ClassTemplateDecl>(ND) && D->getDeclContext()->isDependentContext())
|
|
return true;
|
|
return Visit(ND);
|
|
}
|
|
if (auto Ty = D->getFriendType()) {
|
|
IndexCtx.indexTypeSourceInfo(Ty, cast<NamedDecl>(D->getDeclContext()));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool VisitImportDecl(const ImportDecl *D) {
|
|
return IndexCtx.importedModule(D);
|
|
}
|
|
|
|
bool VisitStaticAssertDecl(const StaticAssertDecl *D) {
|
|
IndexCtx.indexBody(D->getAssertExpr(),
|
|
dyn_cast<NamedDecl>(D->getDeclContext()),
|
|
D->getLexicalDeclContext());
|
|
return true;
|
|
}
|
|
};
|
|
|
|
} // anonymous namespace
|
|
|
|
bool IndexingContext::indexDecl(const Decl *D) {
|
|
if (D->isImplicit() && shouldIgnoreIfImplicit(D))
|
|
return true;
|
|
|
|
if (isTemplateImplicitInstantiation(D) && !shouldIndexImplicitInstantiation())
|
|
return true;
|
|
|
|
IndexingDeclVisitor Visitor(*this);
|
|
bool ShouldContinue = Visitor.Visit(D);
|
|
if (!ShouldContinue)
|
|
return false;
|
|
|
|
if (!Visitor.Handled && isa<DeclContext>(D))
|
|
return indexDeclContext(cast<DeclContext>(D));
|
|
|
|
return true;
|
|
}
|
|
|
|
bool IndexingContext::indexDeclContext(const DeclContext *DC) {
|
|
for (const auto *I : DC->decls())
|
|
if (!indexDecl(I))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool IndexingContext::indexTopLevelDecl(const Decl *D) {
|
|
if (!D || D->getLocation().isInvalid())
|
|
return true;
|
|
|
|
if (isa<ObjCMethodDecl>(D))
|
|
return true; // Wait for the objc container.
|
|
|
|
if (IndexOpts.ShouldTraverseDecl && !IndexOpts.ShouldTraverseDecl(D))
|
|
return true; // skip
|
|
|
|
return indexDecl(D);
|
|
}
|
|
|
|
bool IndexingContext::indexDeclGroupRef(DeclGroupRef DG) {
|
|
for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I)
|
|
if (!indexTopLevelDecl(*I))
|
|
return false;
|
|
return true;
|
|
}
|