contrib/llvm/tools/clang/lib/Index/IndexingContext.cpp

   1 //===- IndexingContext.cpp - Indexing context data ------------------------===//
   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/ASTContext.h"
  13 #include "clang/AST/DeclTemplate.h"
  14 #include "clang/AST/DeclObjC.h"
  15 #include "clang/Basic/SourceManager.h"
  16
  17 using namespace clang;
  18 using namespace index;
  19
  20 static bool isGeneratedDecl(const Decl *D) {
  21   if (auto *attr = D->getAttr<ExternalSourceSymbolAttr>()) {
  22     return attr->getGeneratedDeclaration();
  23   }
  24   return false;
  25 }
  26
  27 bool IndexingContext::shouldIndex(const Decl *D) {
  28   return !isGeneratedDecl(D);
  29 }
  30
  31 const LangOptions &IndexingContext::getLangOpts() const {
  32   return Ctx->getLangOpts();
  33 }
  34
  35 bool IndexingContext::shouldIndexFunctionLocalSymbols() const {
  36   return IndexOpts.IndexFunctionLocals;
  37 }
  38
  39 bool IndexingContext::handleDecl(const Decl *D,
  40                                  SymbolRoleSet Roles,
  41                                  ArrayRef<SymbolRelation> Relations) {
  42   return handleDecl(D, D->getLocation(), Roles, Relations);
  43 }
  44
  45 bool IndexingContext::handleDecl(const Decl *D, SourceLocation Loc,
  46                                  SymbolRoleSet Roles,
  47                                  ArrayRef<SymbolRelation> Relations,
  48                                  const DeclContext *DC) {
  49   if (!DC)
  50     DC = D->getDeclContext();
  51
  52   const Decl *OrigD = D;
  53   if (isa<ObjCPropertyImplDecl>(D)) {
  54     D = cast<ObjCPropertyImplDecl>(D)->getPropertyDecl();
  55   }
  56   return handleDeclOccurrence(D, Loc, /*IsRef=*/false, cast<Decl>(DC),
  57                               Roles, Relations,
  58                               nullptr, OrigD, DC);
  59 }
  60
  61 bool IndexingContext::handleReference(const NamedDecl *D, SourceLocation Loc,
  62                                       const NamedDecl *Parent,
  63                                       const DeclContext *DC,
  64                                       SymbolRoleSet Roles,
  65                                       ArrayRef<SymbolRelation> Relations,
  66                                       const Expr *RefE,
  67                                       const Decl *RefD) {
  68   if (!shouldIndexFunctionLocalSymbols() && isFunctionLocalSymbol(D))
  69     return true;
  70
  71   if (isa<NonTypeTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D))
  72     return true;
  73
  74   return handleDeclOccurrence(D, Loc, /*IsRef=*/true, Parent, Roles, Relations,
  75                               RefE, RefD, DC);
  76 }
  77
  78 bool IndexingContext::importedModule(const ImportDecl *ImportD) {
  79   SourceLocation Loc;
  80   auto IdLocs = ImportD->getIdentifierLocs();
  81   if (!IdLocs.empty())
  82     Loc = IdLocs.front();
  83   else
  84     Loc = ImportD->getLocation();
  85   SourceManager &SM = Ctx->getSourceManager();
  86   Loc = SM.getFileLoc(Loc);
  87   if (Loc.isInvalid())
  88     return true;
  89
  90   FileID FID;
  91   unsigned Offset;
  92   std::tie(FID, Offset) = SM.getDecomposedLoc(Loc);
  93   if (FID.isInvalid())
  94     return true;
  95
  96   bool Invalid = false;
  97   const SrcMgr::SLocEntry &SEntry = SM.getSLocEntry(FID, &Invalid);
  98   if (Invalid || !SEntry.isFile())
  99     return true;
 100
 101   if (SEntry.getFile().getFileCharacteristic() != SrcMgr::C_User) {
 102     switch (IndexOpts.SystemSymbolFilter) {
 103     case IndexingOptions::SystemSymbolFilterKind::None:
 104       return true;
 105     case IndexingOptions::SystemSymbolFilterKind::DeclarationsOnly:
 106     case IndexingOptions::SystemSymbolFilterKind::All:
 107       break;
 108     }
 109   }
 110
 111   SymbolRoleSet Roles = (unsigned)SymbolRole::Declaration;
 112   if (ImportD->isImplicit())
 113     Roles |= (unsigned)SymbolRole::Implicit;
 114
 115   return DataConsumer.handleModuleOccurence(ImportD, Roles, FID, Offset);
 116 }
 117
 118 bool IndexingContext::isTemplateImplicitInstantiation(const Decl *D) {
 119   TemplateSpecializationKind TKind = TSK_Undeclared;
 120   if (const ClassTemplateSpecializationDecl *
 121       SD = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
 122     TKind = SD->getSpecializationKind();
 123   } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
 124     TKind = FD->getTemplateSpecializationKind();
 125   } else if (auto *VD = dyn_cast<VarDecl>(D)) {
 126     TKind = VD->getTemplateSpecializationKind();
 127   } else if (const auto *RD = dyn_cast<CXXRecordDecl>(D)) {
 128     if (RD->getInstantiatedFromMemberClass())
 129       TKind = RD->getTemplateSpecializationKind();
 130   } else if (const auto *ED = dyn_cast<EnumDecl>(D)) {
 131     if (ED->getInstantiatedFromMemberEnum())
 132       TKind = ED->getTemplateSpecializationKind();
 133   } else if (isa<FieldDecl>(D) || isa<TypedefNameDecl>(D) ||
 134              isa<EnumConstantDecl>(D)) {
 135     if (const auto *Parent = dyn_cast<Decl>(D->getDeclContext()))
 136       return isTemplateImplicitInstantiation(Parent);
 137   }
 138   switch (TKind) {
 139     case TSK_Undeclared:
 140     case TSK_ExplicitSpecialization:
 141       return false;
 142     case TSK_ImplicitInstantiation:
 143     case TSK_ExplicitInstantiationDeclaration:
 144     case TSK_ExplicitInstantiationDefinition:
 145       return true;
 146   }
 147   llvm_unreachable("invalid TemplateSpecializationKind");
 148 }
 149
 150 bool IndexingContext::shouldIgnoreIfImplicit(const Decl *D) {
 151   if (isa<ObjCInterfaceDecl>(D))
 152     return false;
 153   if (isa<ObjCCategoryDecl>(D))
 154     return false;
 155   if (isa<ObjCIvarDecl>(D))
 156     return false;
 157   if (isa<ObjCMethodDecl>(D))
 158     return false;
 159   if (isa<ImportDecl>(D))
 160     return false;
 161   return true;
 162 }
 163
 164 static const CXXRecordDecl *
 165 getDeclContextForTemplateInstationPattern(const Decl *D) {
 166   if (const auto *CTSD =
 167           dyn_cast<ClassTemplateSpecializationDecl>(D->getDeclContext()))
 168     return CTSD->getTemplateInstantiationPattern();
 169   else if (const auto *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext()))
 170     return RD->getInstantiatedFromMemberClass();
 171   return nullptr;
 172 }
 173
 174 static const Decl *adjustTemplateImplicitInstantiation(const Decl *D) {
 175   if (const ClassTemplateSpecializationDecl *
 176       SD = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
 177     return SD->getTemplateInstantiationPattern();
 178   } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
 179     return FD->getTemplateInstantiationPattern();
 180   } else if (auto *VD = dyn_cast<VarDecl>(D)) {
 181     return VD->getTemplateInstantiationPattern();
 182   } else if (const auto *RD = dyn_cast<CXXRecordDecl>(D)) {
 183     return RD->getInstantiatedFromMemberClass();
 184   } else if (const auto *ED = dyn_cast<EnumDecl>(D)) {
 185     return ED->getInstantiatedFromMemberEnum();
 186   } else if (isa<FieldDecl>(D) || isa<TypedefNameDecl>(D)) {
 187     const auto *ND = cast<NamedDecl>(D);
 188     if (const CXXRecordDecl *Pattern =
 189             getDeclContextForTemplateInstationPattern(ND)) {
 190       for (const NamedDecl *BaseND : Pattern->lookup(ND->getDeclName())) {
 191         if (BaseND->isImplicit())
 192           continue;
 193         if (BaseND->getKind() == ND->getKind())
 194           return BaseND;
 195       }
 196     }
 197   } else if (const auto *ECD = dyn_cast<EnumConstantDecl>(D)) {
 198     if (const auto *ED = dyn_cast<EnumDecl>(ECD->getDeclContext())) {
 199       if (const EnumDecl *Pattern = ED->getInstantiatedFromMemberEnum()) {
 200         for (const NamedDecl *BaseECD : Pattern->lookup(ECD->getDeclName()))
 201           return BaseECD;
 202       }
 203     }
 204   }
 205   return nullptr;
 206 }
 207
 208 static bool isDeclADefinition(const Decl *D, const DeclContext *ContainerDC, ASTContext &Ctx) {
 209   if (auto VD = dyn_cast<VarDecl>(D))
 210     return VD->isThisDeclarationADefinition(Ctx);
 211
 212   if (auto FD = dyn_cast<FunctionDecl>(D))
 213     return FD->isThisDeclarationADefinition();
 214
 215   if (auto TD = dyn_cast<TagDecl>(D))
 216     return TD->isThisDeclarationADefinition();
 217
 218   if (auto MD = dyn_cast<ObjCMethodDecl>(D))
 219     return MD->isThisDeclarationADefinition() || isa<ObjCImplDecl>(ContainerDC);
 220
 221   if (isa<TypedefNameDecl>(D) ||
 222       isa<EnumConstantDecl>(D) ||
 223       isa<FieldDecl>(D) ||
 224       isa<MSPropertyDecl>(D) ||
 225       isa<ObjCImplDecl>(D) ||
 226       isa<ObjCPropertyImplDecl>(D))
 227     return true;
 228
 229   return false;
 230 }
 231
 232 static const Decl *adjustParent(const Decl *Parent) {
 233   if (!Parent)
 234     return nullptr;
 235   for (;; Parent = cast<Decl>(Parent->getDeclContext())) {
 236     if (isa<TranslationUnitDecl>(Parent))
 237       return nullptr;
 238     if (isa<LinkageSpecDecl>(Parent) || isa<BlockDecl>(Parent))
 239       continue;
 240     if (auto NS = dyn_cast<NamespaceDecl>(Parent)) {
 241       if (NS->isAnonymousNamespace())
 242         continue;
 243     } else if (auto RD = dyn_cast<RecordDecl>(Parent)) {
 244       if (RD->isAnonymousStructOrUnion())
 245         continue;
 246     } else if (auto FD = dyn_cast<FieldDecl>(Parent)) {
 247       if (FD->getDeclName().isEmpty())
 248         continue;
 249     }
 250     return Parent;
 251   }
 252 }
 253
 254 static const Decl *getCanonicalDecl(const Decl *D) {
 255   D = D->getCanonicalDecl();
 256   if (auto TD = dyn_cast<TemplateDecl>(D)) {
 257     D = TD->getTemplatedDecl();
 258     assert(D->isCanonicalDecl());
 259   }
 260
 261   return D;
 262 }
 263
 264 static bool shouldReportOccurrenceForSystemDeclOnlyMode(
 265     bool IsRef, SymbolRoleSet Roles, ArrayRef<SymbolRelation> Relations) {
 266   if (!IsRef)
 267     return true;
 268
 269   auto acceptForRelation = [](SymbolRoleSet roles) -> bool {
 270     bool accept = false;
 271     applyForEachSymbolRoleInterruptible(roles, [&accept](SymbolRole r) -> bool {
 272       switch (r) {
 273       case SymbolRole::RelationChildOf:
 274       case SymbolRole::RelationBaseOf:
 275       case SymbolRole::RelationOverrideOf:
 276       case SymbolRole::RelationExtendedBy:
 277       case SymbolRole::RelationAccessorOf:
 278       case SymbolRole::RelationIBTypeOf:
 279         accept = true;
 280         return false;
 281       case SymbolRole::Declaration:
 282       case SymbolRole::Definition:
 283       case SymbolRole::Reference:
 284       case SymbolRole::Read:
 285       case SymbolRole::Write:
 286       case SymbolRole::Call:
 287       case SymbolRole::Dynamic:
 288       case SymbolRole::AddressOf:
 289       case SymbolRole::Implicit:
 290       case SymbolRole::RelationReceivedBy:
 291       case SymbolRole::RelationCalledBy:
 292       case SymbolRole::RelationContainedBy:
 293       case SymbolRole::RelationSpecializationOf:
 294         return true;
 295       }
 296       llvm_unreachable("Unsupported SymbolRole value!");
 297     });
 298     return accept;
 299   };
 300
 301   for (auto &Rel : Relations) {
 302     if (acceptForRelation(Rel.Roles))
 303       return true;
 304   }
 305
 306   return false;
 307 }
 308
 309 bool IndexingContext::handleDeclOccurrence(const Decl *D, SourceLocation Loc,
 310                                            bool IsRef, const Decl *Parent,
 311                                            SymbolRoleSet Roles,
 312                                            ArrayRef<SymbolRelation> Relations,
 313                                            const Expr *OrigE,
 314                                            const Decl *OrigD,
 315                                            const DeclContext *ContainerDC) {
 316   if (D->isImplicit() && !isa<ObjCMethodDecl>(D))
 317     return true;
 318   if (!isa<NamedDecl>(D) ||
 319       (cast<NamedDecl>(D)->getDeclName().isEmpty() &&
 320        !isa<TagDecl>(D) && !isa<ObjCCategoryDecl>(D)))
 321     return true;
 322
 323   SourceManager &SM = Ctx->getSourceManager();
 324   Loc = SM.getFileLoc(Loc);
 325   if (Loc.isInvalid())
 326     return true;
 327
 328   FileID FID;
 329   unsigned Offset;
 330   std::tie(FID, Offset) = SM.getDecomposedLoc(Loc);
 331   if (FID.isInvalid())
 332     return true;
 333
 334   bool Invalid = false;
 335   const SrcMgr::SLocEntry &SEntry = SM.getSLocEntry(FID, &Invalid);
 336   if (Invalid || !SEntry.isFile())
 337     return true;
 338
 339   if (SEntry.getFile().getFileCharacteristic() != SrcMgr::C_User) {
 340     switch (IndexOpts.SystemSymbolFilter) {
 341     case IndexingOptions::SystemSymbolFilterKind::None:
 342       return true;
 343     case IndexingOptions::SystemSymbolFilterKind::DeclarationsOnly:
 344       if (!shouldReportOccurrenceForSystemDeclOnlyMode(IsRef, Roles, Relations))
 345         return true;
 346       break;
 347     case IndexingOptions::SystemSymbolFilterKind::All:
 348       break;
 349     }
 350   }
 351
 352   if (isTemplateImplicitInstantiation(D)) {
 353     if (!IsRef)
 354       return true;
 355     D = adjustTemplateImplicitInstantiation(D);
 356     if (!D)
 357       return true;
 358     assert(!isTemplateImplicitInstantiation(D));
 359   }
 360
 361   if (!OrigD)
 362     OrigD = D;
 363
 364   if (IsRef)
 365     Roles |= (unsigned)SymbolRole::Reference;
 366   else if (isDeclADefinition(OrigD, ContainerDC, *Ctx))
 367     Roles |= (unsigned)SymbolRole::Definition;
 368   else
 369     Roles |= (unsigned)SymbolRole::Declaration;
 370
 371   D = getCanonicalDecl(D);
 372   Parent = adjustParent(Parent);
 373   if (Parent)
 374     Parent = getCanonicalDecl(Parent);
 375
 376   SmallVector<SymbolRelation, 6> FinalRelations;
 377   FinalRelations.reserve(Relations.size()+1);
 378
 379   auto addRelation = [&](SymbolRelation Rel) {
 380     auto It = std::find_if(FinalRelations.begin(), FinalRelations.end(),
 381                 [&](SymbolRelation Elem)->bool {
 382                   return Elem.RelatedSymbol == Rel.RelatedSymbol;
 383                 });
 384     if (It != FinalRelations.end()) {
 385       It->Roles |= Rel.Roles;
 386     } else {
 387       FinalRelations.push_back(Rel);
 388     }
 389     Roles |= Rel.Roles;
 390   };
 391
 392   if (Parent) {
 393     if (IsRef || (!isa<ParmVarDecl>(D) && isFunctionLocalSymbol(D))) {
 394       addRelation(SymbolRelation{
 395         (unsigned)SymbolRole::RelationContainedBy,
 396         Parent
 397       });
 398     } else {
 399       addRelation(SymbolRelation{
 400         (unsigned)SymbolRole::RelationChildOf,
 401         Parent
 402       });
 403     }
 404   }
 405
 406   for (auto &Rel : Relations) {
 407     addRelation(SymbolRelation(Rel.Roles,
 408                                Rel.RelatedSymbol->getCanonicalDecl()));
 409   }
 410
 411   IndexDataConsumer::ASTNodeInfo Node{ OrigE, OrigD, Parent, ContainerDC };
 412   return DataConsumer.handleDeclOccurence(D, Roles, FinalRelations, FID, Offset,
 413                                           Node);
 414 }