clang/lib/Index/IndexTypeSourceInfo.cpp

   1 //===- IndexTypeSourceInfo.cpp - Indexing types ---------------------------===//
   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/ASTConcept.h"
  11 #include "clang/AST/PrettyPrinter.h"
  12 #include "clang/AST/RecursiveASTVisitor.h"
  13 #include "clang/AST/TypeLoc.h"
  14 #include "llvm/ADT/ScopeExit.h"
  15
  16 using namespace clang;
  17 using namespace index;
  18
  19 namespace {
  20
  21 class TypeIndexer : public RecursiveASTVisitor<TypeIndexer> {
  22   IndexingContext &IndexCtx;
  23   const NamedDecl *Parent;
  24   const DeclContext *ParentDC;
  25   bool IsBase;
  26   SmallVector<SymbolRelation, 3> Relations;
  27
  28   typedef RecursiveASTVisitor<TypeIndexer> base;
  29
  30 public:
  31   TypeIndexer(IndexingContext &indexCtx, const NamedDecl *parent,
  32               const DeclContext *DC, bool isBase, bool isIBType)
  33     : IndexCtx(indexCtx), Parent(parent), ParentDC(DC), IsBase(isBase) {
  34     if (IsBase) {
  35       assert(Parent);
  36       Relations.emplace_back((unsigned)SymbolRole::RelationBaseOf, Parent);
  37     }
  38     if (isIBType) {
  39       assert(Parent);
  40       Relations.emplace_back((unsigned)SymbolRole::RelationIBTypeOf, Parent);
  41     }
  42   }
  43
  44   bool shouldWalkTypesOfTypeLocs() const { return false; }
  45
  46 #define TRY_TO(CALL_EXPR)                                                      \
  47   do {                                                                         \
  48     if (!CALL_EXPR)                                                            \
  49       return false;                                                            \
  50   } while (0)
  51
  52   bool VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TTPL) {
  53     SourceLocation Loc = TTPL.getNameLoc();
  54     TemplateTypeParmDecl *TTPD = TTPL.getDecl();
  55     return IndexCtx.handleReference(TTPD, Loc, Parent, ParentDC,
  56                                     SymbolRoleSet());
  57   }
  58
  59   bool VisitTypedefTypeLoc(TypedefTypeLoc TL) {
  60     SourceLocation Loc = TL.getNameLoc();
  61     TypedefNameDecl *ND = TL.getTypedefNameDecl();
  62     if (ND->isTransparentTag()) {
  63       TagDecl *Underlying = ND->getUnderlyingType()->getAsTagDecl();
  64       return IndexCtx.handleReference(Underlying, Loc, Parent,
  65                                       ParentDC, SymbolRoleSet(), Relations);
  66     }
  67     if (IsBase) {
  68       TRY_TO(IndexCtx.handleReference(ND, Loc,
  69                                       Parent, ParentDC, SymbolRoleSet()));
  70       if (auto *CD = TL.getType()->getAsCXXRecordDecl()) {
  71         TRY_TO(IndexCtx.handleReference(CD, Loc, Parent, ParentDC,
  72                                         (unsigned)SymbolRole::Implicit,
  73                                         Relations));
  74       }
  75     } else {
  76       TRY_TO(IndexCtx.handleReference(ND, Loc,
  77                                       Parent, ParentDC, SymbolRoleSet(),
  78                                       Relations));
  79     }
  80     return true;
  81   }
  82
  83   bool VisitAutoTypeLoc(AutoTypeLoc TL) {
  84     if (auto *C = TL.getNamedConcept())
  85       return IndexCtx.handleReference(C, TL.getConceptNameLoc(), Parent,
  86                                       ParentDC);
  87     return true;
  88   }
  89
  90   bool traverseParamVarHelper(ParmVarDecl *D) {
  91     TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
  92     if (D->getTypeSourceInfo())
  93       TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc()));
  94     return true;
  95   }
  96
  97   bool TraverseParmVarDecl(ParmVarDecl *D) {
  98     // Avoid visiting default arguments from the definition that were already
  99     // visited in the declaration.
 100     // FIXME: A free function definition can have default arguments.
 101     // Avoiding double visitaiton of default arguments should be handled by the
 102     // visitor probably with a bit in the AST to indicate if the attached
 103     // default argument was 'inherited' or written in source.
 104     if (auto FD = dyn_cast<FunctionDecl>(D->getDeclContext())) {
 105       if (FD->isThisDeclarationADefinition()) {
 106         return traverseParamVarHelper(D);
 107       }
 108     }
 109
 110     return base::TraverseParmVarDecl(D);
 111   }
 112
 113   bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS) {
 114     IndexCtx.indexNestedNameSpecifierLoc(NNS, Parent, ParentDC);
 115     return true;
 116   }
 117
 118   bool VisitTagTypeLoc(TagTypeLoc TL) {
 119     TagDecl *D = TL.getDecl();
 120     if (!IndexCtx.shouldIndexFunctionLocalSymbols() &&
 121         D->getParentFunctionOrMethod())
 122       return true;
 123
 124     if (TL.isDefinition()) {
 125       IndexCtx.indexTagDecl(D);
 126       return true;
 127     }
 128
 129     return IndexCtx.handleReference(D, TL.getNameLoc(),
 130                                     Parent, ParentDC, SymbolRoleSet(),
 131                                     Relations);
 132   }
 133
 134   bool VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
 135     return IndexCtx.handleReference(TL.getIFaceDecl(), TL.getNameLoc(),
 136                                     Parent, ParentDC, SymbolRoleSet(), Relations);
 137   }
 138
 139   bool VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
 140     for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) {
 141       IndexCtx.handleReference(TL.getProtocol(i), TL.getProtocolLoc(i),
 142                                Parent, ParentDC, SymbolRoleSet(), Relations);
 143     }
 144     return true;
 145   }
 146
 147   void HandleTemplateSpecializationTypeLoc(TemplateName TemplName,
 148                                            SourceLocation TemplNameLoc,
 149                                            CXXRecordDecl *ResolvedClass,
 150                                            bool IsTypeAlias) {
 151     // In presence of type aliases, the resolved class was never written in
 152     // the code so don't report it.
 153     if (!IsTypeAlias && ResolvedClass &&
 154         (!ResolvedClass->isImplicit() ||
 155          IndexCtx.shouldIndexImplicitInstantiation())) {
 156       IndexCtx.handleReference(ResolvedClass, TemplNameLoc, Parent, ParentDC,
 157                                SymbolRoleSet(), Relations);
 158     } else if (const TemplateDecl *D = TemplName.getAsTemplateDecl()) {
 159       IndexCtx.handleReference(D, TemplNameLoc, Parent, ParentDC,
 160                                SymbolRoleSet(), Relations);
 161     }
 162   }
 163
 164   bool VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL) {
 165     auto *T = TL.getTypePtr();
 166     if (!T)
 167       return true;
 168     HandleTemplateSpecializationTypeLoc(
 169         T->getTemplateName(), TL.getTemplateNameLoc(), T->getAsCXXRecordDecl(),
 170         T->isTypeAlias());
 171     return true;
 172   }
 173
 174   bool TraverseTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL) {
 175     if (!WalkUpFromTemplateSpecializationTypeLoc(TL))
 176       return false;
 177     if (!TraverseTemplateName(TL.getTypePtr()->getTemplateName()))
 178       return false;
 179
 180     // The relations we have to `Parent` do not apply to our template arguments,
 181     // so clear them while visiting the args.
 182     SmallVector<SymbolRelation, 3> SavedRelations = Relations;
 183     Relations.clear();
 184     auto ResetSavedRelations =
 185         llvm::make_scope_exit([&] { this->Relations = SavedRelations; });
 186     for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) {
 187       if (!TraverseTemplateArgumentLoc(TL.getArgLoc(I)))
 188         return false;
 189     }
 190
 191     return true;
 192   }
 193
 194   bool VisitDeducedTemplateSpecializationTypeLoc(DeducedTemplateSpecializationTypeLoc TL) {
 195     auto *T = TL.getTypePtr();
 196     if (!T)
 197       return true;
 198     HandleTemplateSpecializationTypeLoc(
 199         T->getTemplateName(), TL.getTemplateNameLoc(), T->getAsCXXRecordDecl(),
 200         /*IsTypeAlias=*/false);
 201     return true;
 202   }
 203
 204   bool VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
 205     return IndexCtx.handleReference(TL.getDecl(), TL.getNameLoc(), Parent,
 206                                     ParentDC, SymbolRoleSet(), Relations);
 207   }
 208
 209   bool VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
 210     const DependentNameType *DNT = TL.getTypePtr();
 211     const NestedNameSpecifier *NNS = DNT->getQualifier();
 212     const Type *T = NNS->getAsType();
 213     if (!T)
 214       return true;
 215     const TemplateSpecializationType *TST =
 216         T->getAs<TemplateSpecializationType>();
 217     if (!TST)
 218       return true;
 219     TemplateName TN = TST->getTemplateName();
 220     const ClassTemplateDecl *TD =
 221         dyn_cast_or_null<ClassTemplateDecl>(TN.getAsTemplateDecl());
 222     if (!TD)
 223       return true;
 224     CXXRecordDecl *RD = TD->getTemplatedDecl();
 225     if (!RD->hasDefinition())
 226       return true;
 227     RD = RD->getDefinition();
 228     DeclarationName Name(DNT->getIdentifier());
 229     std::vector<const NamedDecl *> Symbols = RD->lookupDependentName(
 230         Name, [](const NamedDecl *ND) { return isa<TypeDecl>(ND); });
 231     if (Symbols.size() != 1)
 232       return true;
 233     return IndexCtx.handleReference(Symbols[0], TL.getNameLoc(), Parent,
 234                                     ParentDC, SymbolRoleSet(), Relations);
 235   }
 236
 237   bool TraverseStmt(Stmt *S) {
 238     IndexCtx.indexBody(S, Parent, ParentDC);
 239     return true;
 240   }
 241 };
 242
 243 } // anonymous namespace
 244
 245 void IndexingContext::indexTypeSourceInfo(TypeSourceInfo *TInfo,
 246                                           const NamedDecl *Parent,
 247                                           const DeclContext *DC,
 248                                           bool isBase,
 249                                           bool isIBType) {
 250   if (!TInfo || TInfo->getTypeLoc().isNull())
 251     return;
 252
 253   indexTypeLoc(TInfo->getTypeLoc(), Parent, DC, isBase, isIBType);
 254 }
 255
 256 void IndexingContext::indexTypeLoc(TypeLoc TL,
 257                                    const NamedDecl *Parent,
 258                                    const DeclContext *DC,
 259                                    bool isBase,
 260                                    bool isIBType) {
 261   if (TL.isNull())
 262     return;
 263
 264   if (!DC)
 265     DC = Parent->getLexicalDeclContext();
 266   TypeIndexer(*this, Parent, DC, isBase, isIBType).TraverseTypeLoc(TL);
 267 }
 268
 269 void IndexingContext::indexNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
 270                                                   const NamedDecl *Parent,
 271                                                   const DeclContext *DC) {
 272   if (!NNS)
 273     return;
 274
 275   if (NestedNameSpecifierLoc Prefix = NNS.getPrefix())
 276     indexNestedNameSpecifierLoc(Prefix, Parent, DC);
 277
 278   if (!DC)
 279     DC = Parent->getLexicalDeclContext();
 280   SourceLocation Loc = NNS.getLocalBeginLoc();
 281
 282   switch (NNS.getNestedNameSpecifier()->getKind()) {
 283   case NestedNameSpecifier::Identifier:
 284   case NestedNameSpecifier::Global:
 285   case NestedNameSpecifier::Super:
 286     break;
 287
 288   case NestedNameSpecifier::Namespace:
 289     handleReference(NNS.getNestedNameSpecifier()->getAsNamespace(),
 290                     Loc, Parent, DC, SymbolRoleSet());
 291     break;
 292   case NestedNameSpecifier::NamespaceAlias:
 293     handleReference(NNS.getNestedNameSpecifier()->getAsNamespaceAlias(),
 294                     Loc, Parent, DC, SymbolRoleSet());
 295     break;
 296
 297   case NestedNameSpecifier::TypeSpec:
 298   case NestedNameSpecifier::TypeSpecWithTemplate:
 299     indexTypeLoc(NNS.getTypeLoc(), Parent, DC);
 300     break;
 301   }
 302 }
 303
 304 void IndexingContext::indexTagDecl(const TagDecl *D,
 305                                    ArrayRef<SymbolRelation> Relations) {
 306   if (!shouldIndex(D))
 307     return;
 308   if (!shouldIndexFunctionLocalSymbols() && isFunctionLocalSymbol(D))
 309     return;
 310
 311   if (handleDecl(D, /*Roles=*/SymbolRoleSet(), Relations)) {
 312     if (D->isThisDeclarationADefinition()) {
 313       indexNestedNameSpecifierLoc(D->getQualifierLoc(), D);
 314       if (auto CXXRD = dyn_cast<CXXRecordDecl>(D)) {
 315         for (const auto &I : CXXRD->bases()) {
 316           indexTypeSourceInfo(I.getTypeSourceInfo(), CXXRD, CXXRD, /*isBase=*/true);
 317         }
 318       }
 319       indexDeclContext(D);
 320     }
 321   }
 322 }