• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===- IndexTypeSourceInfo.cpp - Indexing types ---------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "IndexingContext.h"
11 #include "clang/AST/RecursiveASTVisitor.h"
12 
13 using namespace clang;
14 using namespace index;
15 
16 namespace {
17 
18 class TypeIndexer : public RecursiveASTVisitor<TypeIndexer> {
19   IndexingContext &IndexCtx;
20   const NamedDecl *Parent;
21   const DeclContext *ParentDC;
22   bool IsBase;
23   SmallVector<SymbolRelation, 3> Relations;
24 
25   typedef RecursiveASTVisitor<TypeIndexer> base;
26 
27 public:
TypeIndexer(IndexingContext & indexCtx,const NamedDecl * parent,const DeclContext * DC,bool isBase)28   TypeIndexer(IndexingContext &indexCtx, const NamedDecl *parent,
29               const DeclContext *DC, bool isBase)
30     : IndexCtx(indexCtx), Parent(parent), ParentDC(DC), IsBase(isBase) {
31     if (IsBase) {
32       assert(Parent);
33       Relations.emplace_back((unsigned)SymbolRole::RelationBaseOf, Parent);
34     }
35   }
36 
shouldWalkTypesOfTypeLocs() const37   bool shouldWalkTypesOfTypeLocs() const { return false; }
38 
VisitTypedefTypeLoc(TypedefTypeLoc TL)39   bool VisitTypedefTypeLoc(TypedefTypeLoc TL) {
40     return IndexCtx.handleReference(TL.getTypedefNameDecl(), TL.getNameLoc(),
41                                     Parent, ParentDC, SymbolRoleSet(),
42                                     Relations);
43   }
44 
45 #define TRY_TO(CALL_EXPR)                                                      \
46   do {                                                                         \
47     if (!CALL_EXPR)                                                            \
48       return false;                                                            \
49   } while (0)
50 
traverseParamVarHelper(ParmVarDecl * D)51   bool traverseParamVarHelper(ParmVarDecl *D) {
52     TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
53     if (D->getTypeSourceInfo())
54       TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc()));
55     return true;
56   }
57 
TraverseParmVarDecl(ParmVarDecl * D)58   bool TraverseParmVarDecl(ParmVarDecl *D) {
59     // Avoid visiting default arguments from the definition that were already
60     // visited in the declaration.
61     // FIXME: A free function definition can have default arguments.
62     // Avoiding double visitaiton of default arguments should be handled by the
63     // visitor probably with a bit in the AST to indicate if the attached
64     // default argument was 'inherited' or written in source.
65     if (auto FD = dyn_cast<FunctionDecl>(D->getDeclContext())) {
66       if (FD->isThisDeclarationADefinition()) {
67         return traverseParamVarHelper(D);
68       }
69     }
70 
71     return base::TraverseParmVarDecl(D);
72   }
73 
TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS)74   bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS) {
75     IndexCtx.indexNestedNameSpecifierLoc(NNS, Parent, ParentDC);
76     return true;
77   }
78 
VisitTagTypeLoc(TagTypeLoc TL)79   bool VisitTagTypeLoc(TagTypeLoc TL) {
80     TagDecl *D = TL.getDecl();
81     if (D->getParentFunctionOrMethod())
82       return true;
83 
84     if (TL.isDefinition()) {
85       IndexCtx.indexTagDecl(D);
86       return true;
87     }
88 
89     return IndexCtx.handleReference(D, TL.getNameLoc(),
90                                     Parent, ParentDC, SymbolRoleSet(),
91                                     Relations);
92   }
93 
VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL)94   bool VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
95     return IndexCtx.handleReference(TL.getIFaceDecl(), TL.getNameLoc(),
96                                     Parent, ParentDC, SymbolRoleSet());
97   }
98 
VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL)99   bool VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
100     for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) {
101       IndexCtx.handleReference(TL.getProtocol(i), TL.getProtocolLoc(i),
102                                Parent, ParentDC, SymbolRoleSet());
103     }
104     return true;
105   }
106 
VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL)107   bool VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL) {
108     if (const TemplateSpecializationType *T = TL.getTypePtr()) {
109       if (IndexCtx.shouldIndexImplicitTemplateInsts()) {
110         if (CXXRecordDecl *RD = T->getAsCXXRecordDecl())
111           IndexCtx.handleReference(RD, TL.getTemplateNameLoc(),
112                                    Parent, ParentDC, SymbolRoleSet(), Relations);
113       } else {
114         if (const TemplateDecl *D = T->getTemplateName().getAsTemplateDecl())
115           IndexCtx.handleReference(D, TL.getTemplateNameLoc(),
116                                    Parent, ParentDC, SymbolRoleSet(), Relations);
117       }
118     }
119     return true;
120   }
121 
TraverseStmt(Stmt * S)122   bool TraverseStmt(Stmt *S) {
123     IndexCtx.indexBody(S, Parent, ParentDC);
124     return true;
125   }
126 };
127 
128 } // anonymous namespace
129 
indexTypeSourceInfo(TypeSourceInfo * TInfo,const NamedDecl * Parent,const DeclContext * DC,bool isBase)130 void IndexingContext::indexTypeSourceInfo(TypeSourceInfo *TInfo,
131                                           const NamedDecl *Parent,
132                                           const DeclContext *DC,
133                                           bool isBase) {
134   if (!TInfo || TInfo->getTypeLoc().isNull())
135     return;
136 
137   indexTypeLoc(TInfo->getTypeLoc(), Parent, DC, isBase);
138 }
139 
indexTypeLoc(TypeLoc TL,const NamedDecl * Parent,const DeclContext * DC,bool isBase)140 void IndexingContext::indexTypeLoc(TypeLoc TL,
141                                    const NamedDecl *Parent,
142                                    const DeclContext *DC,
143                                    bool isBase) {
144   if (TL.isNull())
145     return;
146 
147   if (!DC)
148     DC = Parent->getLexicalDeclContext();
149   TypeIndexer(*this, Parent, DC, isBase).TraverseTypeLoc(TL);
150 }
151 
indexNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,const NamedDecl * Parent,const DeclContext * DC)152 void IndexingContext::indexNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
153                                                   const NamedDecl *Parent,
154                                                   const DeclContext *DC) {
155   if (!NNS)
156     return;
157 
158   if (NestedNameSpecifierLoc Prefix = NNS.getPrefix())
159     indexNestedNameSpecifierLoc(Prefix, Parent, DC);
160 
161   if (!DC)
162     DC = Parent->getLexicalDeclContext();
163   SourceLocation Loc = NNS.getSourceRange().getBegin();
164 
165   switch (NNS.getNestedNameSpecifier()->getKind()) {
166   case NestedNameSpecifier::Identifier:
167   case NestedNameSpecifier::Global:
168   case NestedNameSpecifier::Super:
169     break;
170 
171   case NestedNameSpecifier::Namespace:
172     handleReference(NNS.getNestedNameSpecifier()->getAsNamespace(),
173                     Loc, Parent, DC, SymbolRoleSet());
174     break;
175   case NestedNameSpecifier::NamespaceAlias:
176     handleReference(NNS.getNestedNameSpecifier()->getAsNamespaceAlias(),
177                     Loc, Parent, DC, SymbolRoleSet());
178     break;
179 
180   case NestedNameSpecifier::TypeSpec:
181   case NestedNameSpecifier::TypeSpecWithTemplate:
182     indexTypeLoc(NNS.getTypeLoc(), Parent, DC);
183     break;
184   }
185 }
186 
indexTagDecl(const TagDecl * D)187 void IndexingContext::indexTagDecl(const TagDecl *D) {
188   if (!shouldIndexFunctionLocalSymbols() && isFunctionLocalDecl(D))
189     return;
190 
191   if (handleDecl(D)) {
192     if (D->isThisDeclarationADefinition()) {
193       indexNestedNameSpecifierLoc(D->getQualifierLoc(), D);
194       if (auto CXXRD = dyn_cast<CXXRecordDecl>(D)) {
195         for (const auto &I : CXXRD->bases()) {
196           indexTypeSourceInfo(I.getTypeSourceInfo(), CXXRD, CXXRD, /*isBase=*/true);
197         }
198       }
199       indexDeclContext(D);
200     }
201   }
202 }
203