1 //===- IndexBody.cpp - Indexing statements --------------------------------===//
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 clang::index;
15 
16 namespace {
17 
18 class BodyIndexer : public RecursiveASTVisitor<BodyIndexer> {
19   IndexingContext &IndexCtx;
20   const NamedDecl *Parent;
21   const DeclContext *ParentDC;
22   SmallVector<Stmt*, 16> StmtStack;
23 
24   typedef RecursiveASTVisitor<BodyIndexer> base;
25 
26   Stmt *getParentStmt() const {
27     return StmtStack.size() < 2 ? nullptr : StmtStack.end()[-2];
28   }
29 public:
30   BodyIndexer(IndexingContext &indexCtx,
31               const NamedDecl *Parent, const DeclContext *DC)
32     : IndexCtx(indexCtx), Parent(Parent), ParentDC(DC) { }
33 
34   bool shouldWalkTypesOfTypeLocs() const { return false; }
35 
36   bool dataTraverseStmtPre(Stmt *S) {
37     StmtStack.push_back(S);
38     return true;
39   }
40 
41   bool dataTraverseStmtPost(Stmt *S) {
42     assert(StmtStack.back() == S);
43     StmtStack.pop_back();
44     return true;
45   }
46 
47   bool TraverseTypeLoc(TypeLoc TL) {
48     IndexCtx.indexTypeLoc(TL, Parent, ParentDC);
49     return true;
50   }
51 
52   bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS) {
53     IndexCtx.indexNestedNameSpecifierLoc(NNS, Parent, ParentDC);
54     return true;
55   }
56 
57   SymbolRoleSet getRolesForRef(const Expr *E,
58                                SmallVectorImpl<SymbolRelation> &Relations) {
59     SymbolRoleSet Roles{};
60     assert(!StmtStack.empty() && E == StmtStack.back());
61     if (StmtStack.size() == 1)
62       return Roles;
63     auto It = StmtStack.end()-2;
64     while (isa<CastExpr>(*It) || isa<ParenExpr>(*It)) {
65       if (auto ICE = dyn_cast<ImplicitCastExpr>(*It)) {
66         if (ICE->getCastKind() == CK_LValueToRValue)
67           Roles |= (unsigned)(unsigned)SymbolRole::Read;
68       }
69       if (It == StmtStack.begin())
70         break;
71       --It;
72     }
73     const Stmt *Parent = *It;
74 
75     if (auto BO = dyn_cast<BinaryOperator>(Parent)) {
76       if (BO->getOpcode() == BO_Assign && BO->getLHS()->IgnoreParenCasts() == E)
77         Roles |= (unsigned)SymbolRole::Write;
78 
79     } else if (auto UO = dyn_cast<UnaryOperator>(Parent)) {
80       if (UO->isIncrementDecrementOp()) {
81         Roles |= (unsigned)SymbolRole::Read;
82         Roles |= (unsigned)SymbolRole::Write;
83       } else if (UO->getOpcode() == UO_AddrOf) {
84         Roles |= (unsigned)SymbolRole::AddressOf;
85       }
86 
87     } else if (auto CA = dyn_cast<CompoundAssignOperator>(Parent)) {
88       if (CA->getLHS()->IgnoreParenCasts() == E) {
89         Roles |= (unsigned)SymbolRole::Read;
90         Roles |= (unsigned)SymbolRole::Write;
91       }
92 
93     } else if (auto CE = dyn_cast<CallExpr>(Parent)) {
94       if (CE->getCallee()->IgnoreParenCasts() == E) {
95         addCallRole(Roles, Relations);
96         if (auto *ME = dyn_cast<MemberExpr>(E)) {
97           if (auto *CXXMD = dyn_cast_or_null<CXXMethodDecl>(ME->getMemberDecl()))
98             if (CXXMD->isVirtual() && !ME->hasQualifier()) {
99               Roles |= (unsigned)SymbolRole::Dynamic;
100               auto BaseTy = ME->getBase()->IgnoreImpCasts()->getType();
101               if (!BaseTy.isNull())
102                 if (auto *CXXRD = BaseTy->getPointeeCXXRecordDecl())
103                   Relations.emplace_back((unsigned)SymbolRole::RelationReceivedBy,
104                                          CXXRD);
105             }
106         }
107       } else if (auto CXXOp = dyn_cast<CXXOperatorCallExpr>(CE)) {
108         if (CXXOp->getNumArgs() > 0 && CXXOp->getArg(0)->IgnoreParenCasts() == E) {
109           OverloadedOperatorKind Op = CXXOp->getOperator();
110           if (Op == OO_Equal) {
111             Roles |= (unsigned)SymbolRole::Write;
112           } else if ((Op >= OO_PlusEqual && Op <= OO_PipeEqual) ||
113                      Op == OO_LessLessEqual || Op == OO_GreaterGreaterEqual ||
114                      Op == OO_PlusPlus || Op == OO_MinusMinus) {
115             Roles |= (unsigned)SymbolRole::Read;
116             Roles |= (unsigned)SymbolRole::Write;
117           } else if (Op == OO_Amp) {
118             Roles |= (unsigned)SymbolRole::AddressOf;
119           }
120         }
121       }
122     }
123 
124     return Roles;
125   }
126 
127   void addCallRole(SymbolRoleSet &Roles,
128                    SmallVectorImpl<SymbolRelation> &Relations) {
129     Roles |= (unsigned)SymbolRole::Call;
130     if (auto *FD = dyn_cast<FunctionDecl>(ParentDC))
131       Relations.emplace_back((unsigned)SymbolRole::RelationCalledBy, FD);
132     else if (auto *MD = dyn_cast<ObjCMethodDecl>(ParentDC))
133       Relations.emplace_back((unsigned)SymbolRole::RelationCalledBy, MD);
134   }
135 
136   bool VisitDeclRefExpr(DeclRefExpr *E) {
137     SmallVector<SymbolRelation, 4> Relations;
138     SymbolRoleSet Roles = getRolesForRef(E, Relations);
139     return IndexCtx.handleReference(E->getDecl(), E->getLocation(),
140                                     Parent, ParentDC, Roles, Relations, E);
141   }
142 
143   bool VisitMemberExpr(MemberExpr *E) {
144     SourceLocation Loc = E->getMemberLoc();
145     if (Loc.isInvalid())
146       Loc = E->getLocStart();
147     SmallVector<SymbolRelation, 4> Relations;
148     SymbolRoleSet Roles = getRolesForRef(E, Relations);
149     return IndexCtx.handleReference(E->getMemberDecl(), Loc,
150                                     Parent, ParentDC, Roles, Relations, E);
151   }
152 
153   bool indexDependentReference(
154       const Expr *E, const Type *T, const DeclarationNameInfo &NameInfo,
155       llvm::function_ref<bool(const NamedDecl *ND)> Filter) {
156     if (!T)
157       return true;
158     const TemplateSpecializationType *TST =
159         T->getAs<TemplateSpecializationType>();
160     if (!TST)
161       return true;
162     TemplateName TN = TST->getTemplateName();
163     const ClassTemplateDecl *TD =
164         dyn_cast_or_null<ClassTemplateDecl>(TN.getAsTemplateDecl());
165     if (!TD)
166       return true;
167     CXXRecordDecl *RD = TD->getTemplatedDecl();
168     if (!RD->hasDefinition())
169       return true;
170     RD = RD->getDefinition();
171     std::vector<const NamedDecl *> Symbols =
172         RD->lookupDependentName(NameInfo.getName(), Filter);
173     // FIXME: Improve overload handling.
174     if (Symbols.size() != 1)
175       return true;
176     SourceLocation Loc = NameInfo.getLoc();
177     if (Loc.isInvalid())
178       Loc = E->getLocStart();
179     SmallVector<SymbolRelation, 4> Relations;
180     SymbolRoleSet Roles = getRolesForRef(E, Relations);
181     return IndexCtx.handleReference(Symbols[0], Loc, Parent, ParentDC, Roles,
182                                     Relations, E);
183   }
184 
185   bool VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E) {
186     const DeclarationNameInfo &Info = E->getMemberNameInfo();
187     return indexDependentReference(
188         E, E->getBaseType().getTypePtrOrNull(), Info,
189         [](const NamedDecl *D) { return D->isCXXInstanceMember(); });
190   }
191 
192   bool VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
193     const DeclarationNameInfo &Info = E->getNameInfo();
194     const NestedNameSpecifier *NNS = E->getQualifier();
195     return indexDependentReference(
196         E, NNS->getAsType(), Info,
197         [](const NamedDecl *D) { return !D->isCXXInstanceMember(); });
198   }
199 
200   bool VisitDesignatedInitExpr(DesignatedInitExpr *E) {
201     for (DesignatedInitExpr::Designator &D : llvm::reverse(E->designators())) {
202       if (D.isFieldDesignator() && D.getField())
203         return IndexCtx.handleReference(D.getField(), D.getFieldLoc(), Parent,
204                                         ParentDC, SymbolRoleSet(), {}, E);
205     }
206     return true;
207   }
208 
209   bool VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
210     SmallVector<SymbolRelation, 4> Relations;
211     SymbolRoleSet Roles = getRolesForRef(E, Relations);
212     return IndexCtx.handleReference(E->getDecl(), E->getLocation(),
213                                     Parent, ParentDC, Roles, Relations, E);
214   }
215 
216   bool VisitObjCMessageExpr(ObjCMessageExpr *E) {
217     auto isDynamic = [](const ObjCMessageExpr *MsgE)->bool {
218       if (MsgE->getReceiverKind() != ObjCMessageExpr::Instance)
219         return false;
220       if (auto *RecE = dyn_cast<ObjCMessageExpr>(
221               MsgE->getInstanceReceiver()->IgnoreParenCasts())) {
222         if (RecE->getMethodFamily() == OMF_alloc)
223           return false;
224       }
225       return true;
226     };
227 
228     if (ObjCMethodDecl *MD = E->getMethodDecl()) {
229       SymbolRoleSet Roles{};
230       SmallVector<SymbolRelation, 2> Relations;
231       addCallRole(Roles, Relations);
232       Stmt *Containing = getParentStmt();
233       if (E->isImplicit() || (Containing && isa<PseudoObjectExpr>(Containing)))
234         Roles |= (unsigned)SymbolRole::Implicit;
235 
236       if (isDynamic(E)) {
237         Roles |= (unsigned)SymbolRole::Dynamic;
238         if (auto *RecD = E->getReceiverInterface())
239           Relations.emplace_back((unsigned)SymbolRole::RelationReceivedBy, RecD);
240       }
241 
242       return IndexCtx.handleReference(MD, E->getSelectorStartLoc(),
243                                       Parent, ParentDC, Roles, Relations, E);
244     }
245     return true;
246   }
247 
248   bool VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
249     if (E->isClassReceiver())
250       IndexCtx.handleReference(E->getClassReceiver(), E->getReceiverLocation(),
251                                Parent, ParentDC);
252     if (E->isExplicitProperty()) {
253       SmallVector<SymbolRelation, 2> Relations;
254       SymbolRoleSet Roles = getRolesForRef(E, Relations);
255       return IndexCtx.handleReference(E->getExplicitProperty(), E->getLocation(),
256                                       Parent, ParentDC, Roles, Relations, E);
257     } else if (const ObjCMethodDecl *Getter = E->getImplicitPropertyGetter()) {
258       // Class properties that are explicitly defined using @property
259       // declarations are represented implicitly as there is no ivar for class
260       // properties.
261       if (Getter->isClassMethod()) {
262         if (const auto *PD = Getter->getCanonicalDecl()->findPropertyDecl()) {
263           SmallVector<SymbolRelation, 2> Relations;
264           SymbolRoleSet Roles = getRolesForRef(E, Relations);
265           return IndexCtx.handleReference(PD, E->getLocation(), Parent,
266                                           ParentDC, Roles, Relations, E);
267         }
268       }
269     }
270 
271     // No need to do a handleReference for the objc method, because there will
272     // be a message expr as part of PseudoObjectExpr.
273     return true;
274   }
275 
276   bool VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
277     return IndexCtx.handleReference(E->getPropertyDecl(), E->getMemberLoc(),
278                                     Parent, ParentDC, SymbolRoleSet(), {}, E);
279   }
280 
281   bool VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
282     return IndexCtx.handleReference(E->getProtocol(), E->getProtocolIdLoc(),
283                                     Parent, ParentDC, SymbolRoleSet(), {}, E);
284   }
285 
286   bool passObjCLiteralMethodCall(const ObjCMethodDecl *MD, const Expr *E) {
287     SymbolRoleSet Roles{};
288     SmallVector<SymbolRelation, 2> Relations;
289     addCallRole(Roles, Relations);
290     Roles |= (unsigned)SymbolRole::Implicit;
291     return IndexCtx.handleReference(MD, E->getLocStart(),
292                                     Parent, ParentDC, Roles, Relations, E);
293   }
294 
295   bool VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
296     if (ObjCMethodDecl *MD = E->getBoxingMethod()) {
297       return passObjCLiteralMethodCall(MD, E);
298     }
299     return true;
300   }
301 
302   bool VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
303     if (ObjCMethodDecl *MD = E->getDictWithObjectsMethod()) {
304       return passObjCLiteralMethodCall(MD, E);
305     }
306     return true;
307   }
308 
309   bool VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
310     if (ObjCMethodDecl *MD = E->getArrayWithObjectsMethod()) {
311       return passObjCLiteralMethodCall(MD, E);
312     }
313     return true;
314   }
315 
316   bool VisitCXXConstructExpr(CXXConstructExpr *E) {
317     SymbolRoleSet Roles{};
318     SmallVector<SymbolRelation, 2> Relations;
319     addCallRole(Roles, Relations);
320     return IndexCtx.handleReference(E->getConstructor(), E->getLocation(),
321                                     Parent, ParentDC, Roles, Relations, E);
322   }
323 
324   bool TraverseCXXOperatorCallExpr(CXXOperatorCallExpr *E,
325                                    DataRecursionQueue *Q = nullptr) {
326     if (E->getOperatorLoc().isInvalid())
327       return true; // implicit.
328     return base::TraverseCXXOperatorCallExpr(E, Q);
329   }
330 
331   bool VisitDeclStmt(DeclStmt *S) {
332     if (IndexCtx.shouldIndexFunctionLocalSymbols()) {
333       IndexCtx.indexDeclGroupRef(S->getDeclGroup());
334       return true;
335     }
336 
337     DeclGroupRef DG = S->getDeclGroup();
338     for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I) {
339       const Decl *D = *I;
340       if (!D)
341         continue;
342       if (!isFunctionLocalSymbol(D))
343         IndexCtx.indexTopLevelDecl(D);
344     }
345 
346     return true;
347   }
348 
349   bool TraverseLambdaCapture(LambdaExpr *LE, const LambdaCapture *C,
350                              Expr *Init) {
351     if (C->capturesThis() || C->capturesVLAType())
352       return true;
353 
354     if (C->capturesVariable() && IndexCtx.shouldIndexFunctionLocalSymbols())
355       return IndexCtx.handleReference(C->getCapturedVar(), C->getLocation(),
356                                       Parent, ParentDC, SymbolRoleSet());
357 
358     // FIXME: Lambda init-captures.
359     return true;
360   }
361 
362   // RecursiveASTVisitor visits both syntactic and semantic forms, duplicating
363   // the things that we visit. Make sure to only visit the semantic form.
364   // Also visit things that are in the syntactic form but not the semantic one,
365   // for example the indices in DesignatedInitExprs.
366   bool TraverseInitListExpr(InitListExpr *S, DataRecursionQueue *Q = nullptr) {
367     auto visitForm = [&](InitListExpr *Form) {
368       for (Stmt *SubStmt : Form->children()) {
369         if (!TraverseStmt(SubStmt, Q))
370           return false;
371       }
372       return true;
373     };
374 
375     auto visitSyntacticDesignatedInitExpr = [&](DesignatedInitExpr *E) -> bool {
376       for (DesignatedInitExpr::Designator &D : llvm::reverse(E->designators())) {
377         if (D.isFieldDesignator())
378           return IndexCtx.handleReference(D.getField(), D.getFieldLoc(),
379                                           Parent, ParentDC, SymbolRoleSet(),
380                                           {}, E);
381       }
382       return true;
383     };
384 
385     InitListExpr *SemaForm = S->isSemanticForm() ? S : S->getSemanticForm();
386     InitListExpr *SyntaxForm = S->isSemanticForm() ? S->getSyntacticForm() : S;
387 
388     if (SemaForm) {
389       // Visit things present in syntactic form but not the semantic form.
390       if (SyntaxForm) {
391         for (Expr *init : SyntaxForm->inits()) {
392           if (auto *DIE = dyn_cast<DesignatedInitExpr>(init))
393             visitSyntacticDesignatedInitExpr(DIE);
394         }
395       }
396       return visitForm(SemaForm);
397     }
398 
399     // No semantic, try the syntactic.
400     if (SyntaxForm) {
401       return visitForm(SyntaxForm);
402     }
403 
404     return true;
405   }
406 };
407 
408 } // anonymous namespace
409 
410 void IndexingContext::indexBody(const Stmt *S, const NamedDecl *Parent,
411                                 const DeclContext *DC) {
412   if (!S)
413     return;
414 
415   if (!DC)
416     DC = Parent->getLexicalDeclContext();
417   BodyIndexer(*this, Parent, DC).TraverseStmt(const_cast<Stmt*>(S));
418 }
419