contrib/llvm/tools/clang/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_TO(CALL_EXPR)                                                      \
  18   do {                                                                         \
  19     if (!CALL_EXPR)                                                            \
  20       return false;                                                            \
  21   } while (0)
  22
  23 namespace {
  24
  25 class IndexingDeclVisitor : public ConstDeclVisitor<IndexingDeclVisitor, bool> {
  26   IndexingContext &IndexCtx;
  27
  28 public:
  29   explicit IndexingDeclVisitor(IndexingContext &indexCtx)
  30     : IndexCtx(indexCtx) { }
  31
  32   bool Handled = true;
  33
  34   bool VisitDecl(const Decl *D) {
  35     Handled = false;
  36     return true;
  37   }
  38
  39   /// \brief Returns true if the given method has been defined explicitly by the
  40   /// user.
  41   static bool hasUserDefined(const ObjCMethodDecl *D,
  42                              const ObjCImplDecl *Container) {
  43     const ObjCMethodDecl *MD = Container->getMethod(D->getSelector(),
  44                                                     D->isInstanceMethod());
  45     return MD && !MD->isImplicit() && MD->isThisDeclarationADefinition();
  46   }
  47
  48   void handleDeclarator(const DeclaratorDecl *D,
  49                         const NamedDecl *Parent = nullptr,
  50                         bool isIBType = false) {
  51     if (!Parent) Parent = D;
  52
  53     IndexCtx.indexTypeSourceInfo(D->getTypeSourceInfo(), Parent,
  54                                  Parent->getLexicalDeclContext(),
  55                                  /*isBase=*/false, isIBType);
  56     IndexCtx.indexNestedNameSpecifierLoc(D->getQualifierLoc(), Parent);
  57     if (IndexCtx.shouldIndexFunctionLocalSymbols()) {
  58       // Only index parameters in definitions, parameters in declarations are
  59       // not useful.
  60       if (const ParmVarDecl *Parm = dyn_cast<ParmVarDecl>(D)) {
  61         auto *DC = Parm->getDeclContext();
  62         if (auto *FD = dyn_cast<FunctionDecl>(DC)) {
  63           if (FD->isThisDeclarationADefinition())
  64             IndexCtx.handleDecl(Parm);
  65         } else if (auto *MD = dyn_cast<ObjCMethodDecl>(DC)) {
  66           if (MD->isThisDeclarationADefinition())
  67             IndexCtx.handleDecl(Parm);
  68         } else {
  69           IndexCtx.handleDecl(Parm);
  70         }
  71       } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
  72         if (FD->isThisDeclarationADefinition()) {
  73           for (auto PI : FD->parameters()) {
  74             IndexCtx.handleDecl(PI);
  75           }
  76         }
  77       }
  78     }
  79   }
  80
  81   bool handleObjCMethod(const ObjCMethodDecl *D,
  82                         const ObjCPropertyDecl *AssociatedProp = nullptr) {
  83     SmallVector<SymbolRelation, 4> Relations;
  84     SmallVector<const ObjCMethodDecl*, 4> Overriden;
  85
  86     D->getOverriddenMethods(Overriden);
  87     for(auto overridden: Overriden) {
  88       Relations.emplace_back((unsigned) SymbolRole::RelationOverrideOf,
  89                              overridden);
  90     }
  91     if (AssociatedProp)
  92       Relations.emplace_back((unsigned)SymbolRole::RelationAccessorOf,
  93                              AssociatedProp);
  94
  95     if (!IndexCtx.handleDecl(D, (unsigned)SymbolRole::Dynamic, Relations))
  96       return false;
  97     IndexCtx.indexTypeSourceInfo(D->getReturnTypeSourceInfo(), D);
  98     bool hasIBActionAndFirst = D->hasAttr<IBActionAttr>();
  99     for (const auto *I : D->parameters()) {
 100       handleDeclarator(I, D, /*isIBType=*/hasIBActionAndFirst);
 101       hasIBActionAndFirst = false;
 102     }
 103
 104     if (D->isThisDeclarationADefinition()) {
 105       const Stmt *Body = D->getBody();
 106       if (Body) {
 107         IndexCtx.indexBody(Body, D, D);
 108       }
 109     }
 110     return true;
 111   }
 112
 113   bool VisitFunctionDecl(const FunctionDecl *D) {
 114     if (D->isDeleted())
 115       return true;
 116
 117     SymbolRoleSet Roles{};
 118     SmallVector<SymbolRelation, 4> Relations;
 119     if (auto *CXXMD = dyn_cast<CXXMethodDecl>(D)) {
 120       if (CXXMD->isVirtual())
 121         Roles |= (unsigned)SymbolRole::Dynamic;
 122       for (auto I = CXXMD->begin_overridden_methods(),
 123            E = CXXMD->end_overridden_methods(); I != E; ++I) {
 124         Relations.emplace_back((unsigned)SymbolRole::RelationOverrideOf, *I);
 125       }
 126     }
 127
 128     if (!IndexCtx.handleDecl(D, Roles, Relations))
 129       return false;
 130     handleDeclarator(D);
 131
 132     if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(D)) {
 133       // Constructor initializers.
 134       for (const auto *Init : Ctor->inits()) {
 135         if (Init->isWritten()) {
 136           IndexCtx.indexTypeSourceInfo(Init->getTypeSourceInfo(), D);
 137           if (const FieldDecl *Member = Init->getAnyMember())
 138             IndexCtx.handleReference(Member, Init->getMemberLocation(), D, D,
 139                                      (unsigned)SymbolRole::Write);
 140           IndexCtx.indexBody(Init->getInit(), D, D);
 141         }
 142       }
 143     }
 144
 145     if (D->isThisDeclarationADefinition()) {
 146       const Stmt *Body = D->getBody();
 147       if (Body) {
 148         IndexCtx.indexBody(Body, D, D);
 149       }
 150     }
 151     return true;
 152   }
 153
 154   bool VisitVarDecl(const VarDecl *D) {
 155     if (!IndexCtx.handleDecl(D))
 156       return false;
 157     handleDeclarator(D);
 158     IndexCtx.indexBody(D->getInit(), D);
 159     return true;
 160   }
 161
 162   bool VisitFieldDecl(const FieldDecl *D) {
 163     if (!IndexCtx.handleDecl(D))
 164       return false;
 165     handleDeclarator(D);
 166     if (D->isBitField())
 167       IndexCtx.indexBody(D->getBitWidth(), D);
 168     else if (D->hasInClassInitializer())
 169       IndexCtx.indexBody(D->getInClassInitializer(), D);
 170     return true;
 171   }
 172
 173   bool VisitObjCIvarDecl(const ObjCIvarDecl *D) {
 174     if (D->getSynthesize()) {
 175       // For synthesized ivars, use the location of the ObjC implementation,
 176       // not the location of the property.
 177       // Otherwise the header file containing the @interface will have different
 178       // indexing contents based on whether the @implementation was present or
 179       // not in the translation unit.
 180       return IndexCtx.handleDecl(D,
 181                                  cast<Decl>(D->getDeclContext())->getLocation(),
 182                                  (unsigned)SymbolRole::Implicit);
 183     }
 184     if (!IndexCtx.handleDecl(D))
 185       return false;
 186     handleDeclarator(D);
 187     return true;
 188   }
 189
 190   bool VisitMSPropertyDecl(const MSPropertyDecl *D) {
 191     handleDeclarator(D);
 192     return true;
 193   }
 194
 195   bool VisitEnumConstantDecl(const EnumConstantDecl *D) {
 196     if (!IndexCtx.handleDecl(D))
 197       return false;
 198     IndexCtx.indexBody(D->getInitExpr(), D);
 199     return true;
 200   }
 201
 202   bool VisitTypedefNameDecl(const TypedefNameDecl *D) {
 203     if (!IndexCtx.handleDecl(D))
 204       return false;
 205     IndexCtx.indexTypeSourceInfo(D->getTypeSourceInfo(), D);
 206     return true;
 207   }
 208
 209   bool VisitTagDecl(const TagDecl *D) {
 210     // Non-free standing tags are handled in indexTypeSourceInfo.
 211     if (D->isFreeStanding()) {
 212       if (D->isThisDeclarationADefinition()) {
 213         IndexCtx.indexTagDecl(D);
 214       } else {
 215         auto *Parent = dyn_cast<NamedDecl>(D->getDeclContext());
 216         return IndexCtx.handleReference(D, D->getLocation(), Parent,
 217                                         D->getLexicalDeclContext(),
 218                                         SymbolRoleSet());
 219       }
 220     }
 221     return true;
 222   }
 223
 224   bool handleReferencedProtocols(const ObjCProtocolList &ProtList,
 225                                  const ObjCContainerDecl *ContD) {
 226     ObjCInterfaceDecl::protocol_loc_iterator LI = ProtList.loc_begin();
 227     for (ObjCInterfaceDecl::protocol_iterator
 228          I = ProtList.begin(), E = ProtList.end(); I != E; ++I, ++LI) {
 229       SourceLocation Loc = *LI;
 230       ObjCProtocolDecl *PD = *I;
 231       TRY_TO(IndexCtx.handleReference(PD, Loc, ContD, ContD,
 232           SymbolRoleSet(),
 233           SymbolRelation{(unsigned)SymbolRole::RelationBaseOf, ContD}));
 234     }
 235     return true;
 236   }
 237
 238   bool VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D) {
 239     if (D->isThisDeclarationADefinition()) {
 240       TRY_TO(IndexCtx.handleDecl(D));
 241       if (auto *SuperD = D->getSuperClass()) {
 242         TRY_TO(IndexCtx.handleReference(SuperD, D->getSuperClassLoc(), D, D,
 243             SymbolRoleSet(),
 244             SymbolRelation{(unsigned)SymbolRole::RelationBaseOf, D}));
 245       }
 246       TRY_TO(handleReferencedProtocols(D->getReferencedProtocols(), D));
 247       TRY_TO(IndexCtx.indexDeclContext(D));
 248     } else {
 249       return IndexCtx.handleReference(D, D->getLocation(), nullptr,
 250                                       D->getDeclContext(), SymbolRoleSet());
 251     }
 252     return true;
 253   }
 254
 255   bool VisitObjCProtocolDecl(const ObjCProtocolDecl *D) {
 256     if (D->isThisDeclarationADefinition()) {
 257       TRY_TO(IndexCtx.handleDecl(D));
 258       TRY_TO(handleReferencedProtocols(D->getReferencedProtocols(), D));
 259       TRY_TO(IndexCtx.indexDeclContext(D));
 260     } else {
 261       return IndexCtx.handleReference(D, D->getLocation(), nullptr,
 262                                       D->getDeclContext(), SymbolRoleSet());
 263     }
 264     return true;
 265   }
 266
 267   bool VisitObjCImplementationDecl(const ObjCImplementationDecl *D) {
 268     const ObjCInterfaceDecl *Class = D->getClassInterface();
 269     if (!Class)
 270       return true;
 271
 272     if (Class->isImplicitInterfaceDecl())
 273       IndexCtx.handleDecl(Class);
 274
 275     if (!IndexCtx.handleDecl(D))
 276       return false;
 277
 278     // Index the ivars first to make sure the synthesized ivars are indexed
 279     // before indexing the methods that can reference them.
 280     for (const auto *IvarI : D->ivars())
 281       IndexCtx.indexDecl(IvarI);
 282     for (const auto *I : D->decls()) {
 283       if (!isa<ObjCIvarDecl>(I))
 284         IndexCtx.indexDecl(I);
 285     }
 286
 287     return true;
 288   }
 289
 290   bool VisitObjCCategoryDecl(const ObjCCategoryDecl *D) {
 291     const ObjCInterfaceDecl *C = D->getClassInterface();
 292     if (!C)
 293       return true;
 294     TRY_TO(IndexCtx.handleReference(C, D->getLocation(), D, D, SymbolRoleSet(),
 295                                    SymbolRelation{
 296                                      (unsigned)SymbolRole::RelationExtendedBy, D
 297                                    }));
 298     SourceLocation CategoryLoc = D->getCategoryNameLoc();
 299     if (!CategoryLoc.isValid())
 300       CategoryLoc = D->getLocation();
 301     TRY_TO(IndexCtx.handleDecl(D, CategoryLoc));
 302     TRY_TO(handleReferencedProtocols(D->getReferencedProtocols(), D));
 303     TRY_TO(IndexCtx.indexDeclContext(D));
 304     return true;
 305   }
 306
 307   bool VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl *D) {
 308     const ObjCCategoryDecl *Cat = D->getCategoryDecl();
 309     if (!Cat)
 310       return true;
 311     const ObjCInterfaceDecl *C = D->getClassInterface();
 312     if (C)
 313       TRY_TO(IndexCtx.handleReference(C, D->getLocation(), D, D,
 314                                       SymbolRoleSet()));
 315     SourceLocation CategoryLoc = D->getCategoryNameLoc();
 316     if (!CategoryLoc.isValid())
 317       CategoryLoc = D->getLocation();
 318     if (!IndexCtx.handleDecl(D, CategoryLoc))
 319       return false;
 320     IndexCtx.indexDeclContext(D);
 321     return true;
 322   }
 323
 324   bool VisitObjCMethodDecl(const ObjCMethodDecl *D) {
 325     // Methods associated with a property, even user-declared ones, are
 326     // handled when we handle the property.
 327     if (D->isPropertyAccessor())
 328       return true;
 329
 330     handleObjCMethod(D);
 331     return true;
 332   }
 333
 334   bool VisitObjCPropertyDecl(const ObjCPropertyDecl *D) {
 335     if (ObjCMethodDecl *MD = D->getGetterMethodDecl())
 336       if (MD->getLexicalDeclContext() == D->getLexicalDeclContext())
 337         handleObjCMethod(MD, D);
 338     if (ObjCMethodDecl *MD = D->getSetterMethodDecl())
 339       if (MD->getLexicalDeclContext() == D->getLexicalDeclContext())
 340         handleObjCMethod(MD, D);
 341     if (!IndexCtx.handleDecl(D))
 342       return false;
 343     if (IBOutletCollectionAttr *attr = D->getAttr<IBOutletCollectionAttr>())
 344       IndexCtx.indexTypeSourceInfo(attr->getInterfaceLoc(), D,
 345                                    D->getLexicalDeclContext(), false, true);
 346     IndexCtx.indexTypeSourceInfo(D->getTypeSourceInfo(), D);
 347     return true;
 348   }
 349
 350   bool VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D) {
 351     ObjCPropertyDecl *PD = D->getPropertyDecl();
 352     if (!IndexCtx.handleReference(PD, D->getLocation(),
 353                              /*Parent=*/cast<NamedDecl>(D->getDeclContext()),
 354                              D->getDeclContext(), SymbolRoleSet(), {},
 355                              /*RefE=*/nullptr, D))
 356       return false;
 357
 358     if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic)
 359       return true;
 360     assert(D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize);
 361
 362     if (ObjCIvarDecl *IvarD = D->getPropertyIvarDecl()) {
 363       if (!IvarD->getSynthesize())
 364         IndexCtx.handleReference(IvarD, D->getPropertyIvarDeclLoc(), nullptr,
 365                                  D->getDeclContext(), SymbolRoleSet());
 366     }
 367
 368     auto *ImplD = cast<ObjCImplDecl>(D->getDeclContext());
 369     if (ObjCMethodDecl *MD = PD->getGetterMethodDecl()) {
 370       if (MD->isPropertyAccessor() &&
 371           !hasUserDefined(MD, ImplD))
 372         IndexCtx.handleDecl(MD, D->getLocation(), SymbolRoleSet(), {}, ImplD);
 373     }
 374     if (ObjCMethodDecl *MD = PD->getSetterMethodDecl()) {
 375       if (MD->isPropertyAccessor() &&
 376           !hasUserDefined(MD, ImplD))
 377         IndexCtx.handleDecl(MD, D->getLocation(), SymbolRoleSet(), {}, ImplD);
 378     }
 379     return true;
 380   }
 381
 382   bool VisitNamespaceDecl(const NamespaceDecl *D) {
 383     if (!IndexCtx.handleDecl(D))
 384       return false;
 385     IndexCtx.indexDeclContext(D);
 386     return true;
 387   }
 388
 389   bool VisitUsingDecl(const UsingDecl *D) {
 390     const DeclContext *DC = D->getDeclContext()->getRedeclContext();
 391     const NamedDecl *Parent = dyn_cast<NamedDecl>(DC);
 392
 393     IndexCtx.indexNestedNameSpecifierLoc(D->getQualifierLoc(), Parent,
 394                                          D->getLexicalDeclContext());
 395     for (const auto *I : D->shadows())
 396       IndexCtx.handleReference(I->getUnderlyingDecl(), D->getLocation(), Parent,
 397                                D->getLexicalDeclContext(), SymbolRoleSet());
 398     return true;
 399   }
 400
 401   bool VisitUsingDirectiveDecl(const UsingDirectiveDecl *D) {
 402     const DeclContext *DC = D->getDeclContext()->getRedeclContext();
 403     const NamedDecl *Parent = dyn_cast<NamedDecl>(DC);
 404
 405     IndexCtx.indexNestedNameSpecifierLoc(D->getQualifierLoc(), Parent,
 406                                          D->getLexicalDeclContext());
 407     return IndexCtx.handleReference(D->getNominatedNamespaceAsWritten(),
 408                                     D->getLocation(), Parent,
 409                                     D->getLexicalDeclContext(),
 410                                     SymbolRoleSet());
 411   }
 412
 413   bool VisitClassTemplateSpecializationDecl(const
 414                                            ClassTemplateSpecializationDecl *D) {
 415     // FIXME: Notify subsequent callbacks if info comes from implicit
 416     // instantiation.
 417     if (D->isThisDeclarationADefinition())
 418       IndexCtx.indexTagDecl(D);
 419     return true;
 420   }
 421
 422   bool VisitTemplateDecl(const TemplateDecl *D) {
 423     // FIXME: Template parameters.
 424     return Visit(D->getTemplatedDecl());
 425   }
 426
 427   bool VisitFriendDecl(const FriendDecl *D) {
 428     if (auto ND = D->getFriendDecl()) {
 429       // FIXME: Ignore a class template in a dependent context, these are not
 430       // linked properly with their redeclarations, ending up with duplicate
 431       // USRs.
 432       // See comment "Friend templates are visible in fairly strange ways." in
 433       // SemaTemplate.cpp which precedes code that prevents the friend template
 434       // from becoming visible from the enclosing context.
 435       if (isa<ClassTemplateDecl>(ND) && D->getDeclContext()->isDependentContext())
 436         return true;
 437       return Visit(ND);
 438     }
 439     if (auto Ty = D->getFriendType()) {
 440       IndexCtx.indexTypeSourceInfo(Ty, cast<NamedDecl>(D->getDeclContext()));
 441     }
 442     return true;
 443   }
 444
 445   bool VisitImportDecl(const ImportDecl *D) {
 446     return IndexCtx.importedModule(D);
 447   }
 448 };
 449
 450 } // anonymous namespace
 451
 452 bool IndexingContext::indexDecl(const Decl *D) {
 453   if (D->isImplicit() && shouldIgnoreIfImplicit(D))
 454     return true;
 455
 456   if (isTemplateImplicitInstantiation(D))
 457     return true;
 458
 459   IndexingDeclVisitor Visitor(*this);
 460   bool ShouldContinue = Visitor.Visit(D);
 461   if (!ShouldContinue)
 462     return false;
 463
 464   if (!Visitor.Handled && isa<DeclContext>(D))
 465     return indexDeclContext(cast<DeclContext>(D));
 466
 467   return true;
 468 }
 469
 470 bool IndexingContext::indexDeclContext(const DeclContext *DC) {
 471   for (const auto *I : DC->decls())
 472     if (!indexDecl(I))
 473       return false;
 474   return true;
 475 }
 476
 477 bool IndexingContext::indexTopLevelDecl(const Decl *D) {
 478   if (D->getLocation().isInvalid())
 479     return true;
 480
 481   if (isa<ObjCMethodDecl>(D))
 482     return true; // Wait for the objc container.
 483
 484   return indexDecl(D);
 485 }
 486
 487 bool IndexingContext::indexDeclGroupRef(DeclGroupRef DG) {
 488   for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I)
 489     if (!indexTopLevelDecl(*I))
 490       return false;
 491   return true;
 492 }