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

   1 //===- IndexTypeSourceInfo.cpp - Indexing types ---------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "IndexingContext.h"
  11 #include "clang/AST/RecursiveASTVisitor.h"
  12
  13 using namespace clang;
  14 using namespace index;
  15
  16 namespace {
  17
  18 class TypeIndexer : public RecursiveASTVisitor<TypeIndexer> {
  19   IndexingContext &IndexCtx;
  20   const NamedDecl *Parent;
  21   const DeclContext *ParentDC;
  22   bool IsBase;
  23   SmallVector<SymbolRelation, 3> Relations;
  24
  25   typedef RecursiveASTVisitor<TypeIndexer> base;
  26
  27 public:
  28   TypeIndexer(IndexingContext &indexCtx, const NamedDecl *parent,
  29               const DeclContext *DC, bool isBase, bool isIBType)
  30     : IndexCtx(indexCtx), Parent(parent), ParentDC(DC), IsBase(isBase) {
  31     if (IsBase) {
  32       assert(Parent);
  33       Relations.emplace_back((unsigned)SymbolRole::RelationBaseOf, Parent);
  34     }
  35     if (isIBType) {
  36       assert(Parent);
  37       Relations.emplace_back((unsigned)SymbolRole::RelationIBTypeOf, Parent);
  38     }
  39   }
  40
  41   bool shouldWalkTypesOfTypeLocs() const { return false; }
  42
  43 #define TRY_TO(CALL_EXPR)                                                      \
  44   do {                                                                         \
  45     if (!CALL_EXPR)                                                            \
  46       return false;                                                            \
  47   } while (0)
  48
  49   bool VisitTypedefTypeLoc(TypedefTypeLoc TL) {
  50     SourceLocation Loc = TL.getNameLoc();
  51     TypedefNameDecl *ND = TL.getTypedefNameDecl();
  52     if (ND->isTransparentTag()) {
  53       TagDecl *Underlying = ND->getUnderlyingType()->getAsTagDecl();
  54       return IndexCtx.handleReference(Underlying, Loc, Parent,
  55                                       ParentDC, SymbolRoleSet(), Relations);
  56     }
  57     if (IsBase) {
  58       TRY_TO(IndexCtx.handleReference(ND, Loc,
  59                                       Parent, ParentDC, SymbolRoleSet()));
  60       if (auto *CD = TL.getType()->getAsCXXRecordDecl()) {
  61         TRY_TO(IndexCtx.handleReference(CD, Loc, Parent, ParentDC,
  62                                         (unsigned)SymbolRole::Implicit,
  63                                         Relations));
  64       }
  65     } else {
  66       TRY_TO(IndexCtx.handleReference(ND, Loc,
  67                                       Parent, ParentDC, SymbolRoleSet(),
  68                                       Relations));
  69     }
  70     return true;
  71   }
  72
  73   bool traverseParamVarHelper(ParmVarDecl *D) {
  74     TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
  75     if (D->getTypeSourceInfo())
  76       TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc()));
  77     return true;
  78   }
  79
  80   bool TraverseParmVarDecl(ParmVarDecl *D) {
  81     // Avoid visiting default arguments from the definition that were already
  82     // visited in the declaration.
  83     // FIXME: A free function definition can have default arguments.
  84     // Avoiding double visitaiton of default arguments should be handled by the
  85     // visitor probably with a bit in the AST to indicate if the attached
  86     // default argument was 'inherited' or written in source.
  87     if (auto FD = dyn_cast<FunctionDecl>(D->getDeclContext())) {
  88       if (FD->isThisDeclarationADefinition()) {
  89         return traverseParamVarHelper(D);
  90       }
  91     }
  92
  93     return base::TraverseParmVarDecl(D);
  94   }
  95
  96   bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS) {
  97     IndexCtx.indexNestedNameSpecifierLoc(NNS, Parent, ParentDC);
  98     return true;
  99   }
 100
 101   bool VisitTagTypeLoc(TagTypeLoc TL) {
 102     TagDecl *D = TL.getDecl();
 103     if (D->getParentFunctionOrMethod())
 104       return true;
 105
 106     if (TL.isDefinition()) {
 107       IndexCtx.indexTagDecl(D);
 108       return true;
 109     }
 110
 111     return IndexCtx.handleReference(D, TL.getNameLoc(),
 112                                     Parent, ParentDC, SymbolRoleSet(),
 113                                     Relations);
 114   }
 115
 116   bool VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
 117     return IndexCtx.handleReference(TL.getIFaceDecl(), TL.getNameLoc(),
 118                                     Parent, ParentDC, SymbolRoleSet(), Relations);
 119   }
 120
 121   bool VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
 122     for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) {
 123       IndexCtx.handleReference(TL.getProtocol(i), TL.getProtocolLoc(i),
 124                                Parent, ParentDC, SymbolRoleSet(), Relations);
 125     }
 126     return true;
 127   }
 128
 129   template<typename TypeLocType>
 130   bool HandleTemplateSpecializationTypeLoc(TypeLocType TL) {
 131     if (const auto *T = TL.getTypePtr()) {
 132       if (IndexCtx.shouldIndexImplicitInstantiation()) {
 133         if (CXXRecordDecl *RD = T->getAsCXXRecordDecl())
 134           IndexCtx.handleReference(RD, TL.getTemplateNameLoc(),
 135                                    Parent, ParentDC, SymbolRoleSet(), Relations);
 136       } else {
 137         if (const TemplateDecl *D = T->getTemplateName().getAsTemplateDecl())
 138           IndexCtx.handleReference(D, TL.getTemplateNameLoc(),
 139                                    Parent, ParentDC, SymbolRoleSet(), Relations);
 140       }
 141     }
 142     return true;
 143   }
 144
 145   bool VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL) {
 146     return HandleTemplateSpecializationTypeLoc(TL);
 147   }
 148
 149   bool VisitDeducedTemplateSpecializationTypeLoc(DeducedTemplateSpecializationTypeLoc TL) {
 150     return HandleTemplateSpecializationTypeLoc(TL);
 151   }
 152
 153   bool VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
 154     const DependentNameType *DNT = TL.getTypePtr();
 155     const NestedNameSpecifier *NNS = DNT->getQualifier();
 156     const Type *T = NNS->getAsType();
 157     if (!T)
 158       return true;
 159     const TemplateSpecializationType *TST =
 160         T->getAs<TemplateSpecializationType>();
 161     if (!TST)
 162       return true;
 163     TemplateName TN = TST->getTemplateName();
 164     const ClassTemplateDecl *TD =
 165         dyn_cast_or_null<ClassTemplateDecl>(TN.getAsTemplateDecl());
 166     if (!TD)
 167       return true;
 168     CXXRecordDecl *RD = TD->getTemplatedDecl();
 169     if (!RD->hasDefinition())
 170       return true;
 171     RD = RD->getDefinition();
 172     DeclarationName Name(DNT->getIdentifier());
 173     std::vector<const NamedDecl *> Symbols = RD->lookupDependentName(
 174         Name, [](const NamedDecl *ND) { return isa<TypeDecl>(ND); });
 175     if (Symbols.size() != 1)
 176       return true;
 177     return IndexCtx.handleReference(Symbols[0], TL.getNameLoc(), Parent,
 178                                     ParentDC, SymbolRoleSet(), Relations);
 179   }
 180
 181   bool TraverseStmt(Stmt *S) {
 182     IndexCtx.indexBody(S, Parent, ParentDC);
 183     return true;
 184   }
 185 };
 186
 187 } // anonymous namespace
 188
 189 void IndexingContext::indexTypeSourceInfo(TypeSourceInfo *TInfo,
 190                                           const NamedDecl *Parent,
 191                                           const DeclContext *DC,
 192                                           bool isBase,
 193                                           bool isIBType) {
 194   if (!TInfo || TInfo->getTypeLoc().isNull())
 195     return;
 196
 197   indexTypeLoc(TInfo->getTypeLoc(), Parent, DC, isBase, isIBType);
 198 }
 199
 200 void IndexingContext::indexTypeLoc(TypeLoc TL,
 201                                    const NamedDecl *Parent,
 202                                    const DeclContext *DC,
 203                                    bool isBase,
 204                                    bool isIBType) {
 205   if (TL.isNull())
 206     return;
 207
 208   if (!DC)
 209     DC = Parent->getLexicalDeclContext();
 210   TypeIndexer(*this, Parent, DC, isBase, isIBType).TraverseTypeLoc(TL);
 211 }
 212
 213 void IndexingContext::indexNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
 214                                                   const NamedDecl *Parent,
 215                                                   const DeclContext *DC) {
 216   if (!NNS)
 217     return;
 218
 219   if (NestedNameSpecifierLoc Prefix = NNS.getPrefix())
 220     indexNestedNameSpecifierLoc(Prefix, Parent, DC);
 221
 222   if (!DC)
 223     DC = Parent->getLexicalDeclContext();
 224   SourceLocation Loc = NNS.getLocalBeginLoc();
 225
 226   switch (NNS.getNestedNameSpecifier()->getKind()) {
 227   case NestedNameSpecifier::Identifier:
 228   case NestedNameSpecifier::Global:
 229   case NestedNameSpecifier::Super:
 230     break;
 231
 232   case NestedNameSpecifier::Namespace:
 233     handleReference(NNS.getNestedNameSpecifier()->getAsNamespace(),
 234                     Loc, Parent, DC, SymbolRoleSet());
 235     break;
 236   case NestedNameSpecifier::NamespaceAlias:
 237     handleReference(NNS.getNestedNameSpecifier()->getAsNamespaceAlias(),
 238                     Loc, Parent, DC, SymbolRoleSet());
 239     break;
 240
 241   case NestedNameSpecifier::TypeSpec:
 242   case NestedNameSpecifier::TypeSpecWithTemplate:
 243     indexTypeLoc(NNS.getTypeLoc(), Parent, DC);
 244     break;
 245   }
 246 }
 247
 248 void IndexingContext::indexTagDecl(const TagDecl *D,
 249                                    ArrayRef<SymbolRelation> Relations) {
 250   if (!shouldIndex(D))
 251     return;
 252   if (!shouldIndexFunctionLocalSymbols() && isFunctionLocalSymbol(D))
 253     return;
 254
 255   if (handleDecl(D, /*Roles=*/SymbolRoleSet(), Relations)) {
 256     if (D->isThisDeclarationADefinition()) {
 257       indexNestedNameSpecifierLoc(D->getQualifierLoc(), D);
 258       if (auto CXXRD = dyn_cast<CXXRecordDecl>(D)) {
 259         for (const auto &I : CXXRD->bases()) {
 260           indexTypeSourceInfo(I.getTypeSourceInfo(), CXXRD, CXXRD, /*isBase=*/true);
 261         }
 262       }
 263       indexDeclContext(D);
 264     }
 265   }
 266 }