xref: /freebsd/contrib/llvm-project/clang/lib/Index/IndexDecl.cpp (revision 62cfcf62f627e5093fb37026a6d8c98e4d2ef04c)
1 //===- IndexDecl.cpp - Indexing declarations ------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "IndexingContext.h"
10 #include "clang/AST/Attr.h"
11 #include "clang/AST/DeclVisitor.h"
12 #include "clang/Index/IndexDataConsumer.h"
13 
14 using namespace clang;
15 using namespace index;
16 
17 #define TRY_DECL(D,CALL_EXPR)                                                  \
18   do {                                                                         \
19     if (!IndexCtx.shouldIndex(D)) return true;                                 \
20     if (!CALL_EXPR)                                                            \
21       return false;                                                            \
22   } while (0)
23 
24 #define TRY_TO(CALL_EXPR)                                                      \
25   do {                                                                         \
26     if (!CALL_EXPR)                                                            \
27       return false;                                                            \
28   } while (0)
29 
30 namespace {
31 
32 class IndexingDeclVisitor : public ConstDeclVisitor<IndexingDeclVisitor, bool> {
33   IndexingContext &IndexCtx;
34 
35 public:
36   explicit IndexingDeclVisitor(IndexingContext &indexCtx)
37     : IndexCtx(indexCtx) { }
38 
39   bool Handled = true;
40 
41   bool VisitDecl(const Decl *D) {
42     Handled = false;
43     return true;
44   }
45 
46   void handleTemplateArgumentLoc(const TemplateArgumentLoc &TALoc,
47                                  const NamedDecl *Parent,
48                                  const DeclContext *DC) {
49     const TemplateArgumentLocInfo &LocInfo = TALoc.getLocInfo();
50     switch (TALoc.getArgument().getKind()) {
51     case TemplateArgument::Expression:
52       IndexCtx.indexBody(LocInfo.getAsExpr(), Parent, DC);
53       break;
54     case TemplateArgument::Type:
55       IndexCtx.indexTypeSourceInfo(LocInfo.getAsTypeSourceInfo(), Parent, DC);
56       break;
57     case TemplateArgument::Template:
58     case TemplateArgument::TemplateExpansion:
59       IndexCtx.indexNestedNameSpecifierLoc(TALoc.getTemplateQualifierLoc(),
60                                            Parent, DC);
61       if (const TemplateDecl *TD = TALoc.getArgument()
62                                        .getAsTemplateOrTemplatePattern()
63                                        .getAsTemplateDecl()) {
64         if (const NamedDecl *TTD = TD->getTemplatedDecl())
65           IndexCtx.handleReference(TTD, TALoc.getTemplateNameLoc(), Parent, DC);
66       }
67       break;
68     default:
69       break;
70     }
71   }
72 
73   /// Returns true if the given method has been defined explicitly by the
74   /// user.
75   static bool hasUserDefined(const ObjCMethodDecl *D,
76                              const ObjCImplDecl *Container) {
77     const ObjCMethodDecl *MD = Container->getMethod(D->getSelector(),
78                                                     D->isInstanceMethod());
79     return MD && !MD->isImplicit() && MD->isThisDeclarationADefinition() &&
80            !MD->isSynthesizedAccessorStub();
81   }
82 
83 
84   void handleDeclarator(const DeclaratorDecl *D,
85                         const NamedDecl *Parent = nullptr,
86                         bool isIBType = false) {
87     if (!Parent) Parent = D;
88 
89     IndexCtx.indexTypeSourceInfo(D->getTypeSourceInfo(), Parent,
90                                  Parent->getLexicalDeclContext(),
91                                  /*isBase=*/false, isIBType);
92     IndexCtx.indexNestedNameSpecifierLoc(D->getQualifierLoc(), Parent);
93     if (IndexCtx.shouldIndexFunctionLocalSymbols()) {
94       if (const ParmVarDecl *Parm = dyn_cast<ParmVarDecl>(D)) {
95         auto *DC = Parm->getDeclContext();
96         if (auto *FD = dyn_cast<FunctionDecl>(DC)) {
97           if (IndexCtx.shouldIndexParametersInDeclarations() ||
98               FD->isThisDeclarationADefinition())
99             IndexCtx.handleDecl(Parm);
100         } else if (auto *MD = dyn_cast<ObjCMethodDecl>(DC)) {
101           if (MD->isThisDeclarationADefinition())
102             IndexCtx.handleDecl(Parm);
103         } else {
104           IndexCtx.handleDecl(Parm);
105         }
106       } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
107         if (IndexCtx.shouldIndexParametersInDeclarations() ||
108             FD->isThisDeclarationADefinition()) {
109           for (auto PI : FD->parameters()) {
110             IndexCtx.handleDecl(PI);
111           }
112         }
113       }
114     } else {
115       // Index the default parameter value for function definitions.
116       if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
117         if (FD->isThisDeclarationADefinition()) {
118           for (const auto *PV : FD->parameters()) {
119             if (PV->hasDefaultArg() && !PV->hasUninstantiatedDefaultArg() &&
120                 !PV->hasUnparsedDefaultArg())
121               IndexCtx.indexBody(PV->getDefaultArg(), D);
122           }
123         }
124       }
125     }
126   }
127 
128   bool handleObjCMethod(const ObjCMethodDecl *D,
129                         const ObjCPropertyDecl *AssociatedProp = nullptr) {
130     SmallVector<SymbolRelation, 4> Relations;
131     SmallVector<const ObjCMethodDecl*, 4> Overriden;
132 
133     D->getOverriddenMethods(Overriden);
134     for(auto overridden: Overriden) {
135       Relations.emplace_back((unsigned) SymbolRole::RelationOverrideOf,
136                              overridden);
137     }
138     if (AssociatedProp)
139       Relations.emplace_back((unsigned)SymbolRole::RelationAccessorOf,
140                              AssociatedProp);
141 
142     // getLocation() returns beginning token of a method declaration, but for
143     // indexing purposes we want to point to the base name.
144     SourceLocation MethodLoc = D->getSelectorStartLoc();
145     if (MethodLoc.isInvalid())
146       MethodLoc = D->getLocation();
147 
148     SourceLocation AttrLoc;
149 
150     // check for (getter=/setter=)
151     if (AssociatedProp) {
152       bool isGetter = !D->param_size();
153       AttrLoc = isGetter ?
154         AssociatedProp->getGetterNameLoc():
155         AssociatedProp->getSetterNameLoc();
156     }
157 
158     SymbolRoleSet Roles = (SymbolRoleSet)SymbolRole::Dynamic;
159     if (D->isImplicit()) {
160       if (AttrLoc.isValid()) {
161         MethodLoc = AttrLoc;
162       } else {
163         Roles |= (SymbolRoleSet)SymbolRole::Implicit;
164       }
165     } else if (AttrLoc.isValid()) {
166       IndexCtx.handleReference(D, AttrLoc, cast<NamedDecl>(D->getDeclContext()),
167                                D->getDeclContext(), 0);
168     }
169 
170     TRY_DECL(D, IndexCtx.handleDecl(D, MethodLoc, Roles, Relations));
171     IndexCtx.indexTypeSourceInfo(D->getReturnTypeSourceInfo(), D);
172     bool hasIBActionAndFirst = D->hasAttr<IBActionAttr>();
173     for (const auto *I : D->parameters()) {
174       handleDeclarator(I, D, /*isIBType=*/hasIBActionAndFirst);
175       hasIBActionAndFirst = false;
176     }
177 
178     if (D->isThisDeclarationADefinition()) {
179       const Stmt *Body = D->getBody();
180       if (Body) {
181         IndexCtx.indexBody(Body, D, D);
182       }
183     }
184     return true;
185   }
186 
187   /// Gather the declarations which the given declaration \D overrides in a
188   /// pseudo-override manner.
189   ///
190   /// Pseudo-overrides occur when a class template specialization declares
191   /// a declaration that has the same name as a similar declaration in the
192   /// non-specialized template.
193   void
194   gatherTemplatePseudoOverrides(const NamedDecl *D,
195                                 SmallVectorImpl<SymbolRelation> &Relations) {
196     if (!IndexCtx.getLangOpts().CPlusPlus)
197       return;
198     const auto *CTSD =
199         dyn_cast<ClassTemplateSpecializationDecl>(D->getLexicalDeclContext());
200     if (!CTSD)
201       return;
202     llvm::PointerUnion<ClassTemplateDecl *,
203                        ClassTemplatePartialSpecializationDecl *>
204         Template = CTSD->getSpecializedTemplateOrPartial();
205     if (const auto *CTD = Template.dyn_cast<ClassTemplateDecl *>()) {
206       const CXXRecordDecl *Pattern = CTD->getTemplatedDecl();
207       bool TypeOverride = isa<TypeDecl>(D);
208       for (const NamedDecl *ND : Pattern->lookup(D->getDeclName())) {
209         if (const auto *CTD = dyn_cast<ClassTemplateDecl>(ND))
210           ND = CTD->getTemplatedDecl();
211         if (ND->isImplicit())
212           continue;
213         // Types can override other types.
214         if (!TypeOverride) {
215           if (ND->getKind() != D->getKind())
216             continue;
217         } else if (!isa<TypeDecl>(ND))
218           continue;
219         if (const auto *FD = dyn_cast<FunctionDecl>(ND)) {
220           const auto *DFD = cast<FunctionDecl>(D);
221           // Function overrides are approximated using the number of parameters.
222           if (FD->getStorageClass() != DFD->getStorageClass() ||
223               FD->getNumParams() != DFD->getNumParams())
224             continue;
225         }
226         Relations.emplace_back(
227             SymbolRoleSet(SymbolRole::RelationSpecializationOf), ND);
228       }
229     }
230   }
231 
232   bool VisitFunctionDecl(const FunctionDecl *D) {
233     SymbolRoleSet Roles{};
234     SmallVector<SymbolRelation, 4> Relations;
235     if (auto *CXXMD = dyn_cast<CXXMethodDecl>(D)) {
236       if (CXXMD->isVirtual())
237         Roles |= (unsigned)SymbolRole::Dynamic;
238       for (const CXXMethodDecl *O : CXXMD->overridden_methods()) {
239         Relations.emplace_back((unsigned)SymbolRole::RelationOverrideOf, O);
240       }
241     }
242     gatherTemplatePseudoOverrides(D, Relations);
243     if (const auto *Base = D->getPrimaryTemplate())
244       Relations.push_back(
245           SymbolRelation(SymbolRoleSet(SymbolRole::RelationSpecializationOf),
246                          Base->getTemplatedDecl()));
247 
248     TRY_DECL(D, IndexCtx.handleDecl(D, Roles, Relations));
249     handleDeclarator(D);
250 
251     if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(D)) {
252       IndexCtx.handleReference(Ctor->getParent(), Ctor->getLocation(),
253                                Ctor->getParent(), Ctor->getDeclContext(),
254                                (unsigned)SymbolRole::NameReference);
255 
256       // Constructor initializers.
257       for (const auto *Init : Ctor->inits()) {
258         if (Init->isWritten()) {
259           IndexCtx.indexTypeSourceInfo(Init->getTypeSourceInfo(), D);
260           if (const FieldDecl *Member = Init->getAnyMember())
261             IndexCtx.handleReference(Member, Init->getMemberLocation(), D, D,
262                                      (unsigned)SymbolRole::Write);
263           IndexCtx.indexBody(Init->getInit(), D, D);
264         }
265       }
266     } else if (const CXXDestructorDecl *Dtor = dyn_cast<CXXDestructorDecl>(D)) {
267       if (auto TypeNameInfo = Dtor->getNameInfo().getNamedTypeInfo()) {
268         IndexCtx.handleReference(Dtor->getParent(),
269                                  TypeNameInfo->getTypeLoc().getBeginLoc(),
270                                  Dtor->getParent(), Dtor->getDeclContext(),
271                                  (unsigned)SymbolRole::NameReference);
272       }
273     } else if (const auto *Guide = dyn_cast<CXXDeductionGuideDecl>(D)) {
274       IndexCtx.handleReference(Guide->getDeducedTemplate()->getTemplatedDecl(),
275                                Guide->getLocation(), Guide,
276                                Guide->getDeclContext());
277     }
278     // Template specialization arguments.
279     if (const ASTTemplateArgumentListInfo *TemplateArgInfo =
280             D->getTemplateSpecializationArgsAsWritten()) {
281       for (const auto &Arg : TemplateArgInfo->arguments())
282         handleTemplateArgumentLoc(Arg, D, D->getLexicalDeclContext());
283     }
284 
285     if (D->isThisDeclarationADefinition()) {
286       const Stmt *Body = D->getBody();
287       if (Body) {
288         IndexCtx.indexBody(Body, D, D);
289       }
290     }
291     return true;
292   }
293 
294   bool VisitVarDecl(const VarDecl *D) {
295     SmallVector<SymbolRelation, 4> Relations;
296     gatherTemplatePseudoOverrides(D, Relations);
297     TRY_DECL(D, IndexCtx.handleDecl(D, SymbolRoleSet(), Relations));
298     handleDeclarator(D);
299     IndexCtx.indexBody(D->getInit(), D);
300     return true;
301   }
302 
303   bool VisitDecompositionDecl(const DecompositionDecl *D) {
304     for (const auto *Binding : D->bindings())
305       TRY_DECL(Binding, IndexCtx.handleDecl(Binding));
306     return Base::VisitDecompositionDecl(D);
307   }
308 
309   bool VisitFieldDecl(const FieldDecl *D) {
310     SmallVector<SymbolRelation, 4> Relations;
311     gatherTemplatePseudoOverrides(D, Relations);
312     TRY_DECL(D, IndexCtx.handleDecl(D, SymbolRoleSet(), Relations));
313     handleDeclarator(D);
314     if (D->isBitField())
315       IndexCtx.indexBody(D->getBitWidth(), D);
316     else if (D->hasInClassInitializer())
317       IndexCtx.indexBody(D->getInClassInitializer(), D);
318     return true;
319   }
320 
321   bool VisitObjCIvarDecl(const ObjCIvarDecl *D) {
322     if (D->getSynthesize()) {
323       // handled in VisitObjCPropertyImplDecl
324       return true;
325     }
326     TRY_DECL(D, IndexCtx.handleDecl(D));
327     handleDeclarator(D);
328     return true;
329   }
330 
331   bool VisitMSPropertyDecl(const MSPropertyDecl *D) {
332     TRY_DECL(D, IndexCtx.handleDecl(D));
333     handleDeclarator(D);
334     return true;
335   }
336 
337   bool VisitEnumConstantDecl(const EnumConstantDecl *D) {
338     TRY_DECL(D, IndexCtx.handleDecl(D));
339     IndexCtx.indexBody(D->getInitExpr(), D);
340     return true;
341   }
342 
343   bool VisitTypedefNameDecl(const TypedefNameDecl *D) {
344     if (!D->isTransparentTag()) {
345       SmallVector<SymbolRelation, 4> Relations;
346       gatherTemplatePseudoOverrides(D, Relations);
347       TRY_DECL(D, IndexCtx.handleDecl(D, SymbolRoleSet(), Relations));
348       IndexCtx.indexTypeSourceInfo(D->getTypeSourceInfo(), D);
349     }
350     return true;
351   }
352 
353   bool VisitTagDecl(const TagDecl *D) {
354     // Non-free standing tags are handled in indexTypeSourceInfo.
355     if (D->isFreeStanding()) {
356       if (D->isThisDeclarationADefinition()) {
357         SmallVector<SymbolRelation, 4> Relations;
358         gatherTemplatePseudoOverrides(D, Relations);
359         IndexCtx.indexTagDecl(D, Relations);
360       } else {
361         SmallVector<SymbolRelation, 1> Relations;
362         gatherTemplatePseudoOverrides(D, Relations);
363         return IndexCtx.handleDecl(D, D->getLocation(), SymbolRoleSet(),
364                                    Relations, D->getLexicalDeclContext());
365       }
366     }
367     return true;
368   }
369 
370   bool handleReferencedProtocols(const ObjCProtocolList &ProtList,
371                                  const ObjCContainerDecl *ContD,
372                                  SourceLocation SuperLoc) {
373     ObjCInterfaceDecl::protocol_loc_iterator LI = ProtList.loc_begin();
374     for (ObjCInterfaceDecl::protocol_iterator
375          I = ProtList.begin(), E = ProtList.end(); I != E; ++I, ++LI) {
376       SourceLocation Loc = *LI;
377       ObjCProtocolDecl *PD = *I;
378       SymbolRoleSet roles{};
379       if (Loc == SuperLoc)
380         roles |= (SymbolRoleSet)SymbolRole::Implicit;
381       TRY_TO(IndexCtx.handleReference(PD, Loc, ContD, ContD, roles,
382           SymbolRelation{(unsigned)SymbolRole::RelationBaseOf, ContD}));
383     }
384     return true;
385   }
386 
387   bool VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D) {
388     if (D->isThisDeclarationADefinition()) {
389       TRY_DECL(D, IndexCtx.handleDecl(D));
390       SourceLocation SuperLoc = D->getSuperClassLoc();
391       if (auto *SuperD = D->getSuperClass()) {
392         bool hasSuperTypedef = false;
393         if (auto *TInfo = D->getSuperClassTInfo()) {
394           if (auto *TT = TInfo->getType()->getAs<TypedefType>()) {
395             if (auto *TD = TT->getDecl()) {
396               hasSuperTypedef = true;
397               TRY_TO(IndexCtx.handleReference(TD, SuperLoc, D, D,
398                                               SymbolRoleSet()));
399             }
400           }
401         }
402         SymbolRoleSet superRoles{};
403         if (hasSuperTypedef)
404           superRoles |= (SymbolRoleSet)SymbolRole::Implicit;
405         TRY_TO(IndexCtx.handleReference(SuperD, SuperLoc, D, D, superRoles,
406             SymbolRelation{(unsigned)SymbolRole::RelationBaseOf, D}));
407       }
408       TRY_TO(handleReferencedProtocols(D->getReferencedProtocols(), D,
409                                        SuperLoc));
410       TRY_TO(IndexCtx.indexDeclContext(D));
411     } else {
412       return IndexCtx.handleReference(D, D->getLocation(), nullptr,
413                                       D->getDeclContext(), SymbolRoleSet());
414     }
415     return true;
416   }
417 
418   bool VisitObjCProtocolDecl(const ObjCProtocolDecl *D) {
419     if (D->isThisDeclarationADefinition()) {
420       TRY_DECL(D, IndexCtx.handleDecl(D));
421       TRY_TO(handleReferencedProtocols(D->getReferencedProtocols(), D,
422                                        /*SuperLoc=*/SourceLocation()));
423       TRY_TO(IndexCtx.indexDeclContext(D));
424     } else {
425       return IndexCtx.handleReference(D, D->getLocation(), nullptr,
426                                       D->getDeclContext(), SymbolRoleSet());
427     }
428     return true;
429   }
430 
431   bool VisitObjCImplementationDecl(const ObjCImplementationDecl *D) {
432     const ObjCInterfaceDecl *Class = D->getClassInterface();
433     if (!Class)
434       return true;
435 
436     if (Class->isImplicitInterfaceDecl())
437       IndexCtx.handleDecl(Class);
438 
439     TRY_DECL(D, IndexCtx.handleDecl(D));
440 
441     // Visit implicit @synthesize property implementations first as their
442     // location is reported at the name of the @implementation block. This
443     // serves no purpose other than to simplify the FileCheck-based tests.
444     for (const auto *I : D->property_impls()) {
445       if (I->getLocation().isInvalid())
446         IndexCtx.indexDecl(I);
447     }
448     for (const auto *I : D->decls()) {
449       if (!isa<ObjCPropertyImplDecl>(I) ||
450           cast<ObjCPropertyImplDecl>(I)->getLocation().isValid())
451         IndexCtx.indexDecl(I);
452     }
453 
454     return true;
455   }
456 
457   bool VisitObjCCategoryDecl(const ObjCCategoryDecl *D) {
458     if (!IndexCtx.shouldIndex(D))
459       return true;
460     const ObjCInterfaceDecl *C = D->getClassInterface();
461     if (!C)
462       return true;
463     TRY_TO(IndexCtx.handleReference(C, D->getLocation(), D, D, SymbolRoleSet(),
464                                    SymbolRelation{
465                                      (unsigned)SymbolRole::RelationExtendedBy, D
466                                    }));
467     SourceLocation CategoryLoc = D->getCategoryNameLoc();
468     if (!CategoryLoc.isValid())
469       CategoryLoc = D->getLocation();
470     TRY_TO(IndexCtx.handleDecl(D, CategoryLoc));
471     TRY_TO(handleReferencedProtocols(D->getReferencedProtocols(), D,
472                                      /*SuperLoc=*/SourceLocation()));
473     TRY_TO(IndexCtx.indexDeclContext(D));
474     return true;
475   }
476 
477   bool VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl *D) {
478     const ObjCCategoryDecl *Cat = D->getCategoryDecl();
479     if (!Cat)
480       return true;
481     const ObjCInterfaceDecl *C = D->getClassInterface();
482     if (C)
483       TRY_TO(IndexCtx.handleReference(C, D->getLocation(), D, D,
484                                       SymbolRoleSet()));
485     SourceLocation CategoryLoc = D->getCategoryNameLoc();
486     if (!CategoryLoc.isValid())
487       CategoryLoc = D->getLocation();
488     TRY_DECL(D, IndexCtx.handleDecl(D, CategoryLoc));
489     IndexCtx.indexDeclContext(D);
490     return true;
491   }
492 
493   bool VisitObjCMethodDecl(const ObjCMethodDecl *D) {
494     // Methods associated with a property, even user-declared ones, are
495     // handled when we handle the property.
496     if (D->isPropertyAccessor())
497       return true;
498 
499     handleObjCMethod(D);
500     return true;
501   }
502 
503   bool VisitObjCPropertyDecl(const ObjCPropertyDecl *D) {
504     if (ObjCMethodDecl *MD = D->getGetterMethodDecl())
505       if (MD->getLexicalDeclContext() == D->getLexicalDeclContext())
506         handleObjCMethod(MD, D);
507     if (ObjCMethodDecl *MD = D->getSetterMethodDecl())
508       if (MD->getLexicalDeclContext() == D->getLexicalDeclContext())
509         handleObjCMethod(MD, D);
510     TRY_DECL(D, IndexCtx.handleDecl(D));
511     if (IBOutletCollectionAttr *attr = D->getAttr<IBOutletCollectionAttr>())
512       IndexCtx.indexTypeSourceInfo(attr->getInterfaceLoc(), D,
513                                    D->getLexicalDeclContext(), false, true);
514     IndexCtx.indexTypeSourceInfo(D->getTypeSourceInfo(), D);
515     return true;
516   }
517 
518   bool VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D) {
519     ObjCPropertyDecl *PD = D->getPropertyDecl();
520     auto *Container = cast<ObjCImplDecl>(D->getDeclContext());
521     SourceLocation Loc = D->getLocation();
522     SymbolRoleSet Roles = 0;
523     SmallVector<SymbolRelation, 1> Relations;
524 
525     if (ObjCIvarDecl *ID = D->getPropertyIvarDecl())
526       Relations.push_back({(SymbolRoleSet)SymbolRole::RelationAccessorOf, ID});
527     if (Loc.isInvalid()) {
528       Loc = Container->getLocation();
529       Roles |= (SymbolRoleSet)SymbolRole::Implicit;
530     }
531     TRY_DECL(D, IndexCtx.handleDecl(D, Loc, Roles, Relations));
532 
533     if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic)
534       return true;
535 
536     assert(D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize);
537     SymbolRoleSet AccessorMethodRoles =
538       SymbolRoleSet(SymbolRole::Dynamic) | SymbolRoleSet(SymbolRole::Implicit);
539     if (ObjCMethodDecl *MD = PD->getGetterMethodDecl()) {
540       if (MD->isPropertyAccessor() && !hasUserDefined(MD, Container))
541         IndexCtx.handleDecl(MD, Loc, AccessorMethodRoles, {}, Container);
542     }
543     if (ObjCMethodDecl *MD = PD->getSetterMethodDecl()) {
544       if (MD->isPropertyAccessor() && !hasUserDefined(MD, Container))
545         IndexCtx.handleDecl(MD, Loc, AccessorMethodRoles, {}, Container);
546     }
547     if (ObjCIvarDecl *IvarD = D->getPropertyIvarDecl()) {
548       if (IvarD->getSynthesize()) {
549         // For synthesized ivars, use the location of its name in the
550         // corresponding @synthesize. If there isn't one, use the containing
551         // @implementation's location, rather than the property's location,
552         // otherwise the header file containing the @interface will have different
553         // indexing contents based on whether the @implementation was present or
554         // not in the translation unit.
555         SymbolRoleSet IvarRoles = 0;
556         SourceLocation IvarLoc = D->getPropertyIvarDeclLoc();
557         if (D->getLocation().isInvalid()) {
558           IvarLoc = Container->getLocation();
559           IvarRoles = (SymbolRoleSet)SymbolRole::Implicit;
560         } else if (D->getLocation() == IvarLoc) {
561           IvarRoles = (SymbolRoleSet)SymbolRole::Implicit;
562         }
563         TRY_DECL(IvarD, IndexCtx.handleDecl(IvarD, IvarLoc, IvarRoles));
564       } else {
565         IndexCtx.handleReference(IvarD, D->getPropertyIvarDeclLoc(), nullptr,
566                                  D->getDeclContext(), SymbolRoleSet());
567       }
568     }
569     return true;
570   }
571 
572   bool VisitNamespaceDecl(const NamespaceDecl *D) {
573     TRY_DECL(D, IndexCtx.handleDecl(D));
574     IndexCtx.indexDeclContext(D);
575     return true;
576   }
577 
578   bool VisitNamespaceAliasDecl(const NamespaceAliasDecl *D) {
579     TRY_DECL(D, IndexCtx.handleDecl(D));
580     IndexCtx.indexNestedNameSpecifierLoc(D->getQualifierLoc(), D);
581     IndexCtx.handleReference(D->getAliasedNamespace(), D->getTargetNameLoc(), D,
582                              D->getLexicalDeclContext());
583     return true;
584   }
585 
586   bool VisitUsingDecl(const UsingDecl *D) {
587     IndexCtx.handleDecl(D);
588 
589     const DeclContext *DC = D->getDeclContext()->getRedeclContext();
590     const NamedDecl *Parent = dyn_cast<NamedDecl>(DC);
591     IndexCtx.indexNestedNameSpecifierLoc(D->getQualifierLoc(), Parent,
592                                          D->getLexicalDeclContext());
593     for (const auto *I : D->shadows())
594       IndexCtx.handleReference(I->getUnderlyingDecl(), D->getLocation(), Parent,
595                                D->getLexicalDeclContext(), SymbolRoleSet());
596     return true;
597   }
598 
599   bool VisitUsingDirectiveDecl(const UsingDirectiveDecl *D) {
600     const DeclContext *DC = D->getDeclContext()->getRedeclContext();
601     const NamedDecl *Parent = dyn_cast<NamedDecl>(DC);
602 
603     // NNS for the local 'using namespace' directives is visited by the body
604     // visitor.
605     if (!D->getParentFunctionOrMethod())
606       IndexCtx.indexNestedNameSpecifierLoc(D->getQualifierLoc(), Parent,
607                                            D->getLexicalDeclContext());
608 
609     return IndexCtx.handleReference(D->getNominatedNamespaceAsWritten(),
610                                     D->getLocation(), Parent,
611                                     D->getLexicalDeclContext(),
612                                     SymbolRoleSet());
613   }
614 
615   bool VisitUnresolvedUsingValueDecl(const UnresolvedUsingValueDecl *D) {
616     TRY_DECL(D, IndexCtx.handleDecl(D));
617     const DeclContext *DC = D->getDeclContext()->getRedeclContext();
618     const NamedDecl *Parent = dyn_cast<NamedDecl>(DC);
619     IndexCtx.indexNestedNameSpecifierLoc(D->getQualifierLoc(), Parent,
620                                          D->getLexicalDeclContext());
621     return true;
622   }
623 
624   bool VisitUnresolvedUsingTypenameDecl(const UnresolvedUsingTypenameDecl *D) {
625     TRY_DECL(D, IndexCtx.handleDecl(D));
626     const DeclContext *DC = D->getDeclContext()->getRedeclContext();
627     const NamedDecl *Parent = dyn_cast<NamedDecl>(DC);
628     IndexCtx.indexNestedNameSpecifierLoc(D->getQualifierLoc(), Parent,
629                                          D->getLexicalDeclContext());
630     return true;
631   }
632 
633   bool VisitClassTemplateSpecializationDecl(const
634                                            ClassTemplateSpecializationDecl *D) {
635     // FIXME: Notify subsequent callbacks if info comes from implicit
636     // instantiation.
637     llvm::PointerUnion<ClassTemplateDecl *,
638                        ClassTemplatePartialSpecializationDecl *>
639         Template = D->getSpecializedTemplateOrPartial();
640     const Decl *SpecializationOf =
641         Template.is<ClassTemplateDecl *>()
642             ? (Decl *)Template.get<ClassTemplateDecl *>()
643             : Template.get<ClassTemplatePartialSpecializationDecl *>();
644     if (!D->isThisDeclarationADefinition())
645       IndexCtx.indexNestedNameSpecifierLoc(D->getQualifierLoc(), D);
646     IndexCtx.indexTagDecl(
647         D, SymbolRelation(SymbolRoleSet(SymbolRole::RelationSpecializationOf),
648                           SpecializationOf));
649     if (TypeSourceInfo *TSI = D->getTypeAsWritten())
650       IndexCtx.indexTypeSourceInfo(TSI, /*Parent=*/nullptr,
651                                    D->getLexicalDeclContext());
652     return true;
653   }
654 
655   static bool shouldIndexTemplateParameterDefaultValue(const NamedDecl *D) {
656     // We want to index the template parameters only once when indexing the
657     // canonical declaration.
658     if (!D)
659       return false;
660     if (const auto *FD = dyn_cast<FunctionDecl>(D))
661       return FD->getCanonicalDecl() == FD;
662     else if (const auto *TD = dyn_cast<TagDecl>(D))
663       return TD->getCanonicalDecl() == TD;
664     else if (const auto *VD = dyn_cast<VarDecl>(D))
665       return VD->getCanonicalDecl() == VD;
666     return true;
667   }
668 
669   bool VisitTemplateDecl(const TemplateDecl *D) {
670 
671     const NamedDecl *Parent = D->getTemplatedDecl();
672     if (!Parent)
673       return true;
674 
675     // Index the default values for the template parameters.
676     if (D->getTemplateParameters() &&
677         shouldIndexTemplateParameterDefaultValue(Parent)) {
678       const TemplateParameterList *Params = D->getTemplateParameters();
679       for (const NamedDecl *TP : *Params) {
680         if (IndexCtx.shouldIndexTemplateParameters())
681           IndexCtx.handleDecl(TP);
682         if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(TP)) {
683           if (TTP->hasDefaultArgument())
684             IndexCtx.indexTypeSourceInfo(TTP->getDefaultArgumentInfo(), Parent);
685         } else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(TP)) {
686           if (NTTP->hasDefaultArgument())
687             IndexCtx.indexBody(NTTP->getDefaultArgument(), Parent);
688         } else if (const auto *TTPD = dyn_cast<TemplateTemplateParmDecl>(TP)) {
689           if (TTPD->hasDefaultArgument())
690             handleTemplateArgumentLoc(TTPD->getDefaultArgument(), Parent,
691                                       TP->getLexicalDeclContext());
692         }
693       }
694     }
695 
696     return Visit(Parent);
697   }
698 
699   bool VisitFriendDecl(const FriendDecl *D) {
700     if (auto ND = D->getFriendDecl()) {
701       // FIXME: Ignore a class template in a dependent context, these are not
702       // linked properly with their redeclarations, ending up with duplicate
703       // USRs.
704       // See comment "Friend templates are visible in fairly strange ways." in
705       // SemaTemplate.cpp which precedes code that prevents the friend template
706       // from becoming visible from the enclosing context.
707       if (isa<ClassTemplateDecl>(ND) && D->getDeclContext()->isDependentContext())
708         return true;
709       return Visit(ND);
710     }
711     if (auto Ty = D->getFriendType()) {
712       IndexCtx.indexTypeSourceInfo(Ty, cast<NamedDecl>(D->getDeclContext()));
713     }
714     return true;
715   }
716 
717   bool VisitImportDecl(const ImportDecl *D) {
718     return IndexCtx.importedModule(D);
719   }
720 
721   bool VisitStaticAssertDecl(const StaticAssertDecl *D) {
722     IndexCtx.indexBody(D->getAssertExpr(),
723                        dyn_cast<NamedDecl>(D->getDeclContext()),
724                        D->getLexicalDeclContext());
725     return true;
726   }
727 };
728 
729 } // anonymous namespace
730 
731 bool IndexingContext::indexDecl(const Decl *D) {
732   if (D->isImplicit() && shouldIgnoreIfImplicit(D))
733     return true;
734 
735   if (isTemplateImplicitInstantiation(D) && !shouldIndexImplicitInstantiation())
736     return true;
737 
738   IndexingDeclVisitor Visitor(*this);
739   bool ShouldContinue = Visitor.Visit(D);
740   if (!ShouldContinue)
741     return false;
742 
743   if (!Visitor.Handled && isa<DeclContext>(D))
744     return indexDeclContext(cast<DeclContext>(D));
745 
746   return true;
747 }
748 
749 bool IndexingContext::indexDeclContext(const DeclContext *DC) {
750   for (const auto *I : DC->decls())
751     if (!indexDecl(I))
752       return false;
753   return true;
754 }
755 
756 bool IndexingContext::indexTopLevelDecl(const Decl *D) {
757   if (D->getLocation().isInvalid())
758     return true;
759 
760   if (isa<ObjCMethodDecl>(D))
761     return true; // Wait for the objc container.
762 
763   return indexDecl(D);
764 }
765 
766 bool IndexingContext::indexDeclGroupRef(DeclGroupRef DG) {
767   for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I)
768     if (!indexTopLevelDecl(*I))
769       return false;
770   return true;
771 }
772