clang/lib/Index/IndexBody.cpp

   1 //===- IndexBody.cpp - Indexing statements --------------------------------===//
   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/RecursiveASTVisitor.h"
  11 #include "clang/AST/ASTLambda.h"
  12
  13 using namespace clang;
  14 using namespace clang::index;
  15
  16 namespace {
  17
  18 class BodyIndexer : public RecursiveASTVisitor<BodyIndexer> {
  19   IndexingContext &IndexCtx;
  20   const NamedDecl *Parent;
  21   const DeclContext *ParentDC;
  22   SmallVector<Stmt*, 16> StmtStack;
  23
  24   typedef RecursiveASTVisitor<BodyIndexer> base;
  25
  26   Stmt *getParentStmt() const {
  27     return StmtStack.size() < 2 ? nullptr : StmtStack.end()[-2];
  28   }
  29 public:
  30   BodyIndexer(IndexingContext &indexCtx,
  31               const NamedDecl *Parent, const DeclContext *DC)
  32     : IndexCtx(indexCtx), Parent(Parent), ParentDC(DC) { }
  33
  34   bool shouldWalkTypesOfTypeLocs() const { return false; }
  35
  36   bool dataTraverseStmtPre(Stmt *S) {
  37     StmtStack.push_back(S);
  38     return true;
  39   }
  40
  41   bool dataTraverseStmtPost(Stmt *S) {
  42     assert(StmtStack.back() == S);
  43     StmtStack.pop_back();
  44     return true;
  45   }
  46
  47   bool TraverseTypeLoc(TypeLoc TL) {
  48     IndexCtx.indexTypeLoc(TL, Parent, ParentDC);
  49     return true;
  50   }
  51
  52   bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS) {
  53     IndexCtx.indexNestedNameSpecifierLoc(NNS, Parent, ParentDC);
  54     return true;
  55   }
  56
  57   SymbolRoleSet getRolesForRef(const Expr *E,
  58                                SmallVectorImpl<SymbolRelation> &Relations) {
  59     SymbolRoleSet Roles{};
  60     assert(!StmtStack.empty() && E == StmtStack.back());
  61     if (StmtStack.size() == 1)
  62       return Roles;
  63     auto It = StmtStack.end()-2;
  64     while (isa<CastExpr>(*It) || isa<ParenExpr>(*It)) {
  65       if (auto ICE = dyn_cast<ImplicitCastExpr>(*It)) {
  66         if (ICE->getCastKind() == CK_LValueToRValue)
  67           Roles |= (unsigned)(unsigned)SymbolRole::Read;
  68       }
  69       if (It == StmtStack.begin())
  70         break;
  71       --It;
  72     }
  73     const Stmt *Parent = *It;
  74
  75     if (auto BO = dyn_cast<BinaryOperator>(Parent)) {
  76       if (BO->getOpcode() == BO_Assign && BO->getLHS()->IgnoreParenCasts() == E)
  77         Roles |= (unsigned)SymbolRole::Write;
  78
  79     } else if (auto UO = dyn_cast<UnaryOperator>(Parent)) {
  80       if (UO->isIncrementDecrementOp()) {
  81         Roles |= (unsigned)SymbolRole::Read;
  82         Roles |= (unsigned)SymbolRole::Write;
  83       } else if (UO->getOpcode() == UO_AddrOf) {
  84         Roles |= (unsigned)SymbolRole::AddressOf;
  85       }
  86
  87     } else if (auto CA = dyn_cast<CompoundAssignOperator>(Parent)) {
  88       if (CA->getLHS()->IgnoreParenCasts() == E) {
  89         Roles |= (unsigned)SymbolRole::Read;
  90         Roles |= (unsigned)SymbolRole::Write;
  91       }
  92
  93     } else if (auto CE = dyn_cast<CallExpr>(Parent)) {
  94       if (CE->getCallee()->IgnoreParenCasts() == E) {
  95         addCallRole(Roles, Relations);
  96         if (auto *ME = dyn_cast<MemberExpr>(E)) {
  97           if (auto *CXXMD = dyn_cast_or_null<CXXMethodDecl>(ME->getMemberDecl()))
  98             if (CXXMD->isVirtual() && !ME->hasQualifier()) {
  99               Roles |= (unsigned)SymbolRole::Dynamic;
 100               auto BaseTy = ME->getBase()->IgnoreImpCasts()->getType();
 101               if (!BaseTy.isNull())
 102                 if (auto *CXXRD = BaseTy->getPointeeCXXRecordDecl())
 103                   Relations.emplace_back((unsigned)SymbolRole::RelationReceivedBy,
 104                                          CXXRD);
 105             }
 106         }
 107       } else if (auto CXXOp = dyn_cast<CXXOperatorCallExpr>(CE)) {
 108         if (CXXOp->getNumArgs() > 0 && CXXOp->getArg(0)->IgnoreParenCasts() == E) {
 109           OverloadedOperatorKind Op = CXXOp->getOperator();
 110           if (Op == OO_Equal) {
 111             Roles |= (unsigned)SymbolRole::Write;
 112           } else if ((Op >= OO_PlusEqual && Op <= OO_PipeEqual) ||
 113                      Op == OO_LessLessEqual || Op == OO_GreaterGreaterEqual ||
 114                      Op == OO_PlusPlus || Op == OO_MinusMinus) {
 115             Roles |= (unsigned)SymbolRole::Read;
 116             Roles |= (unsigned)SymbolRole::Write;
 117           } else if (Op == OO_Amp) {
 118             Roles |= (unsigned)SymbolRole::AddressOf;
 119           }
 120         }
 121       }
 122     }
 123
 124     return Roles;
 125   }
 126
 127   void addCallRole(SymbolRoleSet &Roles,
 128                    SmallVectorImpl<SymbolRelation> &Relations) {
 129     Roles |= (unsigned)SymbolRole::Call;
 130     if (auto *FD = dyn_cast<FunctionDecl>(ParentDC))
 131       Relations.emplace_back((unsigned)SymbolRole::RelationCalledBy, FD);
 132     else if (auto *MD = dyn_cast<ObjCMethodDecl>(ParentDC))
 133       Relations.emplace_back((unsigned)SymbolRole::RelationCalledBy, MD);
 134   }
 135
 136   bool VisitDeclRefExpr(DeclRefExpr *E) {
 137     SmallVector<SymbolRelation, 4> Relations;
 138     SymbolRoleSet Roles = getRolesForRef(E, Relations);
 139     return IndexCtx.handleReference(E->getDecl(), E->getLocation(),
 140                                     Parent, ParentDC, Roles, Relations, E);
 141   }
 142
 143   bool VisitMemberExpr(MemberExpr *E) {
 144     SourceLocation Loc = E->getMemberLoc();
 145     if (Loc.isInvalid())
 146       Loc = E->getBeginLoc();
 147     SmallVector<SymbolRelation, 4> Relations;
 148     SymbolRoleSet Roles = getRolesForRef(E, Relations);
 149     return IndexCtx.handleReference(E->getMemberDecl(), Loc,
 150                                     Parent, ParentDC, Roles, Relations, E);
 151   }
 152
 153   bool indexDependentReference(
 154       const Expr *E, const Type *T, const DeclarationNameInfo &NameInfo,
 155       llvm::function_ref<bool(const NamedDecl *ND)> Filter) {
 156     if (!T)
 157       return true;
 158     const TemplateSpecializationType *TST =
 159         T->getAs<TemplateSpecializationType>();
 160     if (!TST)
 161       return true;
 162     TemplateName TN = TST->getTemplateName();
 163     const ClassTemplateDecl *TD =
 164         dyn_cast_or_null<ClassTemplateDecl>(TN.getAsTemplateDecl());
 165     if (!TD)
 166       return true;
 167     CXXRecordDecl *RD = TD->getTemplatedDecl();
 168     if (!RD->hasDefinition())
 169       return true;
 170     RD = RD->getDefinition();
 171     std::vector<const NamedDecl *> Symbols =
 172         RD->lookupDependentName(NameInfo.getName(), Filter);
 173     // FIXME: Improve overload handling.
 174     if (Symbols.size() != 1)
 175       return true;
 176     SourceLocation Loc = NameInfo.getLoc();
 177     if (Loc.isInvalid())
 178       Loc = E->getBeginLoc();
 179     SmallVector<SymbolRelation, 4> Relations;
 180     SymbolRoleSet Roles = getRolesForRef(E, Relations);
 181     return IndexCtx.handleReference(Symbols[0], Loc, Parent, ParentDC, Roles,
 182                                     Relations, E);
 183   }
 184
 185   bool VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E) {
 186     const DeclarationNameInfo &Info = E->getMemberNameInfo();
 187     return indexDependentReference(
 188         E, E->getBaseType().getTypePtrOrNull(), Info,
 189         [](const NamedDecl *D) { return D->isCXXInstanceMember(); });
 190   }
 191
 192   bool VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
 193     const DeclarationNameInfo &Info = E->getNameInfo();
 194     const NestedNameSpecifier *NNS = E->getQualifier();
 195     return indexDependentReference(
 196         E, NNS->getAsType(), Info,
 197         [](const NamedDecl *D) { return !D->isCXXInstanceMember(); });
 198   }
 199
 200   bool VisitDesignatedInitExpr(DesignatedInitExpr *E) {
 201     for (DesignatedInitExpr::Designator &D : llvm::reverse(E->designators())) {
 202       if (D.isFieldDesignator() && D.getField())
 203         return IndexCtx.handleReference(D.getField(), D.getFieldLoc(), Parent,
 204                                         ParentDC, SymbolRoleSet(), {}, E);
 205     }
 206     return true;
 207   }
 208
 209   bool VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
 210     SmallVector<SymbolRelation, 4> Relations;
 211     SymbolRoleSet Roles = getRolesForRef(E, Relations);
 212     return IndexCtx.handleReference(E->getDecl(), E->getLocation(),
 213                                     Parent, ParentDC, Roles, Relations, E);
 214   }
 215
 216   bool VisitObjCMessageExpr(ObjCMessageExpr *E) {
 217     auto isDynamic = [](const ObjCMessageExpr *MsgE)->bool {
 218       if (MsgE->getReceiverKind() != ObjCMessageExpr::Instance)
 219         return false;
 220       if (auto *RecE = dyn_cast<ObjCMessageExpr>(
 221               MsgE->getInstanceReceiver()->IgnoreParenCasts())) {
 222         if (RecE->getMethodFamily() == OMF_alloc)
 223           return false;
 224       }
 225       return true;
 226     };
 227
 228     if (ObjCMethodDecl *MD = E->getMethodDecl()) {
 229       SymbolRoleSet Roles{};
 230       SmallVector<SymbolRelation, 2> Relations;
 231       addCallRole(Roles, Relations);
 232       Stmt *Containing = getParentStmt();
 233
 234       auto IsImplicitProperty = [](const PseudoObjectExpr *POE) -> bool {
 235         const auto *E = POE->getSyntacticForm();
 236         if (const auto *BinOp = dyn_cast<BinaryOperator>(E))
 237           E = BinOp->getLHS();
 238         const auto *PRE = dyn_cast<ObjCPropertyRefExpr>(E);
 239         if (!PRE)
 240           return false;
 241         if (PRE->isExplicitProperty())
 242           return false;
 243         if (const ObjCMethodDecl *Getter = PRE->getImplicitPropertyGetter()) {
 244           // Class properties that are explicitly defined using @property
 245           // declarations are represented implicitly as there is no ivar for
 246           // class properties.
 247           if (Getter->isClassMethod() &&
 248               Getter->getCanonicalDecl()->findPropertyDecl())
 249             return false;
 250         }
 251         return true;
 252       };
 253       bool IsPropCall = Containing && isa<PseudoObjectExpr>(Containing);
 254       // Implicit property message sends are not 'implicit'.
 255       if ((E->isImplicit() || IsPropCall) &&
 256           !(IsPropCall &&
 257             IsImplicitProperty(cast<PseudoObjectExpr>(Containing))))
 258         Roles |= (unsigned)SymbolRole::Implicit;
 259
 260       if (isDynamic(E)) {
 261         Roles |= (unsigned)SymbolRole::Dynamic;
 262
 263         auto addReceivers = [&](const ObjCObjectType *Ty) {
 264           if (!Ty)
 265             return;
 266           if (const auto *clsD = Ty->getInterface()) {
 267             Relations.emplace_back((unsigned)SymbolRole::RelationReceivedBy,
 268                                    clsD);
 269           }
 270           for (const auto *protD : Ty->quals()) {
 271             Relations.emplace_back((unsigned)SymbolRole::RelationReceivedBy,
 272                                    protD);
 273           }
 274         };
 275         QualType recT = E->getReceiverType();
 276         if (const auto *Ptr = recT->getAs<ObjCObjectPointerType>())
 277           addReceivers(Ptr->getObjectType());
 278         else
 279           addReceivers(recT->getAs<ObjCObjectType>());
 280       }
 281
 282       return IndexCtx.handleReference(MD, E->getSelectorStartLoc(),
 283                                       Parent, ParentDC, Roles, Relations, E);
 284     }
 285     return true;
 286   }
 287
 288   bool VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
 289     if (E->isExplicitProperty()) {
 290       SmallVector<SymbolRelation, 2> Relations;
 291       SymbolRoleSet Roles = getRolesForRef(E, Relations);
 292       return IndexCtx.handleReference(E->getExplicitProperty(), E->getLocation(),
 293                                       Parent, ParentDC, Roles, Relations, E);
 294     } else if (const ObjCMethodDecl *Getter = E->getImplicitPropertyGetter()) {
 295       // Class properties that are explicitly defined using @property
 296       // declarations are represented implicitly as there is no ivar for class
 297       // properties.
 298       if (Getter->isClassMethod()) {
 299         if (const auto *PD = Getter->getCanonicalDecl()->findPropertyDecl()) {
 300           SmallVector<SymbolRelation, 2> Relations;
 301           SymbolRoleSet Roles = getRolesForRef(E, Relations);
 302           return IndexCtx.handleReference(PD, E->getLocation(), Parent,
 303                                           ParentDC, Roles, Relations, E);
 304         }
 305       }
 306     }
 307
 308     // No need to do a handleReference for the objc method, because there will
 309     // be a message expr as part of PseudoObjectExpr.
 310     return true;
 311   }
 312
 313   bool VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
 314     return IndexCtx.handleReference(E->getPropertyDecl(), E->getMemberLoc(),
 315                                     Parent, ParentDC, SymbolRoleSet(), {}, E);
 316   }
 317
 318   bool VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
 319     return IndexCtx.handleReference(E->getProtocol(), E->getProtocolIdLoc(),
 320                                     Parent, ParentDC, SymbolRoleSet(), {}, E);
 321   }
 322
 323   bool passObjCLiteralMethodCall(const ObjCMethodDecl *MD, const Expr *E) {
 324     SymbolRoleSet Roles{};
 325     SmallVector<SymbolRelation, 2> Relations;
 326     addCallRole(Roles, Relations);
 327     Roles |= (unsigned)SymbolRole::Implicit;
 328     return IndexCtx.handleReference(MD, E->getBeginLoc(), Parent, ParentDC,
 329                                     Roles, Relations, E);
 330   }
 331
 332   bool VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
 333     if (ObjCMethodDecl *MD = E->getBoxingMethod()) {
 334       return passObjCLiteralMethodCall(MD, E);
 335     }
 336     return true;
 337   }
 338
 339   bool VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
 340     if (ObjCMethodDecl *MD = E->getDictWithObjectsMethod()) {
 341       return passObjCLiteralMethodCall(MD, E);
 342     }
 343     return true;
 344   }
 345
 346   bool VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
 347     if (ObjCMethodDecl *MD = E->getArrayWithObjectsMethod()) {
 348       return passObjCLiteralMethodCall(MD, E);
 349     }
 350     return true;
 351   }
 352
 353   bool VisitCXXConstructExpr(CXXConstructExpr *E) {
 354     SymbolRoleSet Roles{};
 355     SmallVector<SymbolRelation, 2> Relations;
 356     addCallRole(Roles, Relations);
 357     return IndexCtx.handleReference(E->getConstructor(), E->getLocation(),
 358                                     Parent, ParentDC, Roles, Relations, E);
 359   }
 360
 361   bool TraverseCXXOperatorCallExpr(CXXOperatorCallExpr *E,
 362                                    DataRecursionQueue *Q = nullptr) {
 363     if (E->getOperatorLoc().isInvalid())
 364       return true; // implicit.
 365     return base::TraverseCXXOperatorCallExpr(E, Q);
 366   }
 367
 368   bool VisitDeclStmt(DeclStmt *S) {
 369     if (IndexCtx.shouldIndexFunctionLocalSymbols()) {
 370       IndexCtx.indexDeclGroupRef(S->getDeclGroup());
 371       return true;
 372     }
 373
 374     DeclGroupRef DG = S->getDeclGroup();
 375     for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I) {
 376       const Decl *D = *I;
 377       if (!D)
 378         continue;
 379       if (!isFunctionLocalSymbol(D))
 380         IndexCtx.indexTopLevelDecl(D);
 381     }
 382
 383     return true;
 384   }
 385
 386   bool TraverseLambdaCapture(LambdaExpr *LE, const LambdaCapture *C,
 387                              Expr *Init) {
 388     if (C->capturesThis() || C->capturesVLAType())
 389       return true;
 390
 391     if (!base::TraverseStmt(Init))
 392       return false;
 393
 394     if (C->capturesVariable() && IndexCtx.shouldIndexFunctionLocalSymbols())
 395       return IndexCtx.handleReference(C->getCapturedVar(), C->getLocation(),
 396                                       Parent, ParentDC, SymbolRoleSet());
 397
 398     return true;
 399   }
 400
 401   // RecursiveASTVisitor visits both syntactic and semantic forms, duplicating
 402   // the things that we visit. Make sure to only visit the semantic form.
 403   // Also visit things that are in the syntactic form but not the semantic one,
 404   // for example the indices in DesignatedInitExprs.
 405   bool TraverseInitListExpr(InitListExpr *S, DataRecursionQueue *Q = nullptr) {
 406     auto visitForm = [&](InitListExpr *Form) {
 407       for (Stmt *SubStmt : Form->children()) {
 408         if (!TraverseStmt(SubStmt, Q))
 409           return false;
 410       }
 411       return true;
 412     };
 413
 414     auto visitSyntacticDesignatedInitExpr = [&](DesignatedInitExpr *E) -> bool {
 415       for (DesignatedInitExpr::Designator &D : llvm::reverse(E->designators())) {
 416         if (D.isFieldDesignator() && D.getField())
 417           return IndexCtx.handleReference(D.getField(), D.getFieldLoc(),
 418                                           Parent, ParentDC, SymbolRoleSet(),
 419                                           {}, E);
 420       }
 421       return true;
 422     };
 423
 424     InitListExpr *SemaForm = S->isSemanticForm() ? S : S->getSemanticForm();
 425     InitListExpr *SyntaxForm = S->isSemanticForm() ? S->getSyntacticForm() : S;
 426
 427     if (SemaForm) {
 428       // Visit things present in syntactic form but not the semantic form.
 429       if (SyntaxForm) {
 430         for (Expr *init : SyntaxForm->inits()) {
 431           if (auto *DIE = dyn_cast<DesignatedInitExpr>(init))
 432             visitSyntacticDesignatedInitExpr(DIE);
 433         }
 434       }
 435       return visitForm(SemaForm);
 436     }
 437
 438     // No semantic, try the syntactic.
 439     if (SyntaxForm) {
 440       return visitForm(SyntaxForm);
 441     }
 442
 443     return true;
 444   }
 445
 446   bool VisitOffsetOfExpr(OffsetOfExpr *S) {
 447     for (unsigned I = 0, E = S->getNumComponents(); I != E; ++I) {
 448       const OffsetOfNode &Component = S->getComponent(I);
 449       if (Component.getKind() == OffsetOfNode::Field)
 450         IndexCtx.handleReference(Component.getField(), Component.getEndLoc(),
 451                                  Parent, ParentDC, SymbolRoleSet(), {});
 452       // FIXME: Try to resolve dependent field references.
 453     }
 454     return true;
 455   }
 456
 457   bool VisitParmVarDecl(ParmVarDecl* D) {
 458     // Index the parameters of lambda expression.
 459     if (IndexCtx.shouldIndexFunctionLocalSymbols()) {
 460       const auto *DC = D->getDeclContext();
 461       if (DC && isLambdaCallOperator(DC))
 462         IndexCtx.handleDecl(D);
 463     }
 464     return true;
 465   }
 466
 467   bool VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
 468     SmallVector<SymbolRelation, 4> Relations;
 469     SymbolRoleSet Roles = getRolesForRef(E, Relations);
 470     for (auto *D : E->decls())
 471       IndexCtx.handleReference(D, E->getNameLoc(), Parent, ParentDC, Roles,
 472                                Relations, E);
 473     return true;
 474   }
 475 };
 476
 477 } // anonymous namespace
 478
 479 void IndexingContext::indexBody(const Stmt *S, const NamedDecl *Parent,
 480                                 const DeclContext *DC) {
 481   if (!S)
 482     return;
 483
 484   if (!DC)
 485     DC = Parent->getLexicalDeclContext();
 486   BodyIndexer(*this, Parent, DC).TraverseStmt(const_cast<Stmt*>(S));
 487 }