lib/Index/IndexDecl.cpp

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