xref: /freebsd/contrib/llvm-project/clang/lib/Index/IndexingContext.cpp (revision a90b9d0159070121c221b966469c3e36d912bf82) 
1 //===- IndexingContext.cpp - Indexing context data ------------------------===//
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/ASTContext.h"
11 #include "clang/AST/Attr.h"
12 #include "clang/AST/DeclObjC.h"
13 #include "clang/AST/DeclTemplate.h"
14 #include "clang/Basic/SourceLocation.h"
15 #include "clang/Basic/SourceManager.h"
16 #include "clang/Index/IndexDataConsumer.h"
17 
18 using namespace clang;
19 using namespace index;
20 
21 static bool isGeneratedDecl(const Decl *D) {
22   if (auto *attr = D->getAttr<ExternalSourceSymbolAttr>()) {
23     return attr->getGeneratedDeclaration();
24   }
25   return false;
26 }
27 
28 bool IndexingContext::shouldIndex(const Decl *D) {
29   return !isGeneratedDecl(D);
30 }
31 
32 const LangOptions &IndexingContext::getLangOpts() const {
33   return Ctx->getLangOpts();
34 }
35 
36 bool IndexingContext::shouldIndexFunctionLocalSymbols() const {
37   return IndexOpts.IndexFunctionLocals;
38 }
39 
40 bool IndexingContext::shouldIndexImplicitInstantiation() const {
41   return IndexOpts.IndexImplicitInstantiation;
42 }
43 
44 bool IndexingContext::shouldIndexParametersInDeclarations() const {
45   return IndexOpts.IndexParametersInDeclarations;
46 }
47 
48 bool IndexingContext::shouldIndexTemplateParameters() const {
49   return IndexOpts.IndexTemplateParameters;
50 }
51 
52 bool IndexingContext::handleDecl(const Decl *D,
53                                  SymbolRoleSet Roles,
54                                  ArrayRef<SymbolRelation> Relations) {
55   return handleDecl(D, D->getLocation(), Roles, Relations);
56 }
57 
58 bool IndexingContext::handleDecl(const Decl *D, SourceLocation Loc,
59                                  SymbolRoleSet Roles,
60                                  ArrayRef<SymbolRelation> Relations,
61                                  const DeclContext *DC) {
62   if (!DC)
63     DC = D->getDeclContext();
64 
65   const Decl *OrigD = D;
66   if (isa<ObjCPropertyImplDecl>(D)) {
67     D = cast<ObjCPropertyImplDecl>(D)->getPropertyDecl();
68   }
69   return handleDeclOccurrence(D, Loc, /*IsRef=*/false, cast<Decl>(DC),
70                               Roles, Relations,
71                               nullptr, OrigD, DC);
72 }
73 
74 bool IndexingContext::handleReference(const NamedDecl *D, SourceLocation Loc,
75                                       const NamedDecl *Parent,
76                                       const DeclContext *DC,
77                                       SymbolRoleSet Roles,
78                                       ArrayRef<SymbolRelation> Relations,
79                                       const Expr *RefE) {
80   if (!shouldIndexFunctionLocalSymbols() && isFunctionLocalSymbol(D))
81     return true;
82 
83   if (!shouldIndexTemplateParameters() &&
84       (isa<NonTypeTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D) ||
85        isa<TemplateTemplateParmDecl>(D))) {
86     return true;
87   }
88   return handleDeclOccurrence(D, Loc, /*IsRef=*/true, Parent, Roles, Relations,
89                               RefE, nullptr, DC);
90 }
91 
92 static void reportModuleReferences(const Module *Mod,
93                                    ArrayRef<SourceLocation> IdLocs,
94                                    const ImportDecl *ImportD,
95                                    IndexDataConsumer &DataConsumer) {
96   if (!Mod)
97     return;
98   reportModuleReferences(Mod->Parent, IdLocs.drop_back(), ImportD,
99                          DataConsumer);
100   DataConsumer.handleModuleOccurrence(
101       ImportD, Mod, (SymbolRoleSet)SymbolRole::Reference, IdLocs.back());
102 }
103 
104 bool IndexingContext::importedModule(const ImportDecl *ImportD) {
105   if (ImportD->isInvalidDecl())
106     return true;
107 
108   SourceLocation Loc;
109   auto IdLocs = ImportD->getIdentifierLocs();
110   if (!IdLocs.empty())
111     Loc = IdLocs.back();
112   else
113     Loc = ImportD->getLocation();
114 
115   SourceManager &SM = Ctx->getSourceManager();
116   FileID FID = SM.getFileID(SM.getFileLoc(Loc));
117   if (FID.isInvalid())
118     return true;
119 
120   bool Invalid = false;
121   const SrcMgr::SLocEntry &SEntry = SM.getSLocEntry(FID, &Invalid);
122   if (Invalid || !SEntry.isFile())
123     return true;
124 
125   if (SEntry.getFile().getFileCharacteristic() != SrcMgr::C_User) {
126     switch (IndexOpts.SystemSymbolFilter) {
127     case IndexingOptions::SystemSymbolFilterKind::None:
128       return true;
129     case IndexingOptions::SystemSymbolFilterKind::DeclarationsOnly:
130     case IndexingOptions::SystemSymbolFilterKind::All:
131       break;
132     }
133   }
134 
135   const Module *Mod = ImportD->getImportedModule();
136   if (!ImportD->isImplicit() && Mod->Parent && !IdLocs.empty()) {
137     reportModuleReferences(Mod->Parent, IdLocs.drop_back(), ImportD,
138                            DataConsumer);
139   }
140 
141   SymbolRoleSet Roles = (unsigned)SymbolRole::Declaration;
142   if (ImportD->isImplicit())
143     Roles |= (unsigned)SymbolRole::Implicit;
144 
145   return DataConsumer.handleModuleOccurrence(ImportD, Mod, Roles, Loc);
146 }
147 
148 bool IndexingContext::isTemplateImplicitInstantiation(const Decl *D) {
149   TemplateSpecializationKind TKind = TSK_Undeclared;
150   if (const ClassTemplateSpecializationDecl *
151       SD = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
152     TKind = SD->getSpecializationKind();
153   } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
154     TKind = FD->getTemplateSpecializationKind();
155   } else if (auto *VD = dyn_cast<VarDecl>(D)) {
156     TKind = VD->getTemplateSpecializationKind();
157   } else if (const auto *RD = dyn_cast<CXXRecordDecl>(D)) {
158     if (RD->getInstantiatedFromMemberClass())
159       TKind = RD->getTemplateSpecializationKind();
160   } else if (const auto *ED = dyn_cast<EnumDecl>(D)) {
161     if (ED->getInstantiatedFromMemberEnum())
162       TKind = ED->getTemplateSpecializationKind();
163   } else if (isa<FieldDecl>(D) || isa<TypedefNameDecl>(D) ||
164              isa<EnumConstantDecl>(D)) {
165     if (const auto *Parent = dyn_cast<Decl>(D->getDeclContext()))
166       return isTemplateImplicitInstantiation(Parent);
167   }
168   switch (TKind) {
169     case TSK_Undeclared:
170       // Instantiation maybe not happen yet when we see a SpecializationDecl,
171       // e.g. when the type doesn't need to be complete, we still treat it as an
172       // instantiation as we'd like to keep the canonicalized result consistent.
173       return isa<ClassTemplateSpecializationDecl>(D);
174     case TSK_ExplicitSpecialization:
175       return false;
176     case TSK_ImplicitInstantiation:
177     case TSK_ExplicitInstantiationDeclaration:
178     case TSK_ExplicitInstantiationDefinition:
179       return true;
180   }
181   llvm_unreachable("invalid TemplateSpecializationKind");
182 }
183 
184 bool IndexingContext::shouldIgnoreIfImplicit(const Decl *D) {
185   if (isa<ObjCInterfaceDecl>(D))
186     return false;
187   if (isa<ObjCCategoryDecl>(D))
188     return false;
189   if (isa<ObjCIvarDecl>(D))
190     return false;
191   if (isa<ObjCMethodDecl>(D))
192     return false;
193   if (isa<ImportDecl>(D))
194     return false;
195   return true;
196 }
197 
198 static const CXXRecordDecl *
199 getDeclContextForTemplateInstationPattern(const Decl *D) {
200   if (const auto *CTSD =
201           dyn_cast<ClassTemplateSpecializationDecl>(D->getDeclContext()))
202     return CTSD->getTemplateInstantiationPattern();
203   else if (const auto *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext()))
204     return RD->getInstantiatedFromMemberClass();
205   return nullptr;
206 }
207 
208 static const Decl *adjustTemplateImplicitInstantiation(const Decl *D) {
209   if (const ClassTemplateSpecializationDecl *
210       SD = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
211     const auto *Template = SD->getTemplateInstantiationPattern();
212     if (Template)
213       return Template;
214     // Fallback to primary template if no instantiation is available yet (e.g.
215     // the type doesn't need to be complete).
216     return SD->getSpecializedTemplate()->getTemplatedDecl();
217   } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
218     return FD->getTemplateInstantiationPattern();
219   } else if (auto *VD = dyn_cast<VarDecl>(D)) {
220     return VD->getTemplateInstantiationPattern();
221   } else if (const auto *RD = dyn_cast<CXXRecordDecl>(D)) {
222     return RD->getInstantiatedFromMemberClass();
223   } else if (const auto *ED = dyn_cast<EnumDecl>(D)) {
224     return ED->getInstantiatedFromMemberEnum();
225   } else if (isa<FieldDecl>(D) || isa<TypedefNameDecl>(D)) {
226     const auto *ND = cast<NamedDecl>(D);
227     if (const CXXRecordDecl *Pattern =
228             getDeclContextForTemplateInstationPattern(ND)) {
229       for (const NamedDecl *BaseND : Pattern->lookup(ND->getDeclName())) {
230         if (BaseND->isImplicit())
231           continue;
232         if (BaseND->getKind() == ND->getKind())
233           return BaseND;
234       }
235     }
236   } else if (const auto *ECD = dyn_cast<EnumConstantDecl>(D)) {
237     if (const auto *ED = dyn_cast<EnumDecl>(ECD->getDeclContext())) {
238       if (const EnumDecl *Pattern = ED->getInstantiatedFromMemberEnum()) {
239         for (const NamedDecl *BaseECD : Pattern->lookup(ECD->getDeclName()))
240           return BaseECD;
241       }
242     }
243   }
244   return nullptr;
245 }
246 
247 static bool isDeclADefinition(const Decl *D, const DeclContext *ContainerDC, ASTContext &Ctx) {
248   if (auto VD = dyn_cast<VarDecl>(D))
249     return VD->isThisDeclarationADefinition(Ctx);
250 
251   if (auto FD = dyn_cast<FunctionDecl>(D))
252     return FD->isThisDeclarationADefinition();
253 
254   if (auto TD = dyn_cast<TagDecl>(D))
255     return TD->isThisDeclarationADefinition();
256 
257   if (auto MD = dyn_cast<ObjCMethodDecl>(D))
258     return MD->isThisDeclarationADefinition() || isa<ObjCImplDecl>(ContainerDC);
259 
260   if (isa<TypedefNameDecl>(D) || isa<EnumConstantDecl>(D) ||
261       isa<FieldDecl>(D) || isa<MSPropertyDecl>(D) || isa<ObjCImplDecl>(D) ||
262       isa<ObjCPropertyImplDecl>(D) || isa<ConceptDecl>(D))
263     return true;
264 
265   return false;
266 }
267 
268 /// Whether the given NamedDecl should be skipped because it has no name.
269 static bool shouldSkipNamelessDecl(const NamedDecl *ND) {
270   return (ND->getDeclName().isEmpty() && !isa<TagDecl>(ND) &&
271           !isa<ObjCCategoryDecl>(ND)) || isa<CXXDeductionGuideDecl>(ND);
272 }
273 
274 static const Decl *adjustParent(const Decl *Parent) {
275   if (!Parent)
276     return nullptr;
277   for (;; Parent = cast<Decl>(Parent->getDeclContext())) {
278     if (isa<TranslationUnitDecl>(Parent))
279       return nullptr;
280     if (isa<LinkageSpecDecl>(Parent) || isa<BlockDecl>(Parent))
281       continue;
282     if (auto NS = dyn_cast<NamespaceDecl>(Parent)) {
283       if (NS->isAnonymousNamespace())
284         continue;
285     } else if (auto RD = dyn_cast<RecordDecl>(Parent)) {
286       if (RD->isAnonymousStructOrUnion())
287         continue;
288     } else if (auto ND = dyn_cast<NamedDecl>(Parent)) {
289       if (shouldSkipNamelessDecl(ND))
290         continue;
291     }
292     return Parent;
293   }
294 }
295 
296 static const Decl *getCanonicalDecl(const Decl *D) {
297   D = D->getCanonicalDecl();
298   if (auto TD = dyn_cast<TemplateDecl>(D)) {
299     if (auto TTD = TD->getTemplatedDecl()) {
300       D = TTD;
301       assert(D->isCanonicalDecl());
302     }
303   }
304 
305   return D;
306 }
307 
308 static bool shouldReportOccurrenceForSystemDeclOnlyMode(
309     bool IsRef, SymbolRoleSet Roles, ArrayRef<SymbolRelation> Relations) {
310   if (!IsRef)
311     return true;
312 
313   auto acceptForRelation = [](SymbolRoleSet roles) -> bool {
314     bool accept = false;
315     applyForEachSymbolRoleInterruptible(roles, [&accept](SymbolRole r) -> bool {
316       switch (r) {
317       case SymbolRole::RelationChildOf:
318       case SymbolRole::RelationBaseOf:
319       case SymbolRole::RelationOverrideOf:
320       case SymbolRole::RelationExtendedBy:
321       case SymbolRole::RelationAccessorOf:
322       case SymbolRole::RelationIBTypeOf:
323         accept = true;
324         return false;
325       case SymbolRole::Declaration:
326       case SymbolRole::Definition:
327       case SymbolRole::Reference:
328       case SymbolRole::Read:
329       case SymbolRole::Write:
330       case SymbolRole::Call:
331       case SymbolRole::Dynamic:
332       case SymbolRole::AddressOf:
333       case SymbolRole::Implicit:
334       case SymbolRole::Undefinition:
335       case SymbolRole::RelationReceivedBy:
336       case SymbolRole::RelationCalledBy:
337       case SymbolRole::RelationContainedBy:
338       case SymbolRole::RelationSpecializationOf:
339       case SymbolRole::NameReference:
340         return true;
341       }
342       llvm_unreachable("Unsupported SymbolRole value!");
343     });
344     return accept;
345   };
346 
347   for (auto &Rel : Relations) {
348     if (acceptForRelation(Rel.Roles))
349       return true;
350   }
351 
352   return false;
353 }
354 
355 bool IndexingContext::handleDeclOccurrence(const Decl *D, SourceLocation Loc,
356                                            bool IsRef, const Decl *Parent,
357                                            SymbolRoleSet Roles,
358                                            ArrayRef<SymbolRelation> Relations,
359                                            const Expr *OrigE,
360                                            const Decl *OrigD,
361                                            const DeclContext *ContainerDC) {
362   if (D->isImplicit() && !isa<ObjCMethodDecl>(D))
363     return true;
364   if (!isa<NamedDecl>(D) || shouldSkipNamelessDecl(cast<NamedDecl>(D)))
365     return true;
366 
367   SourceManager &SM = Ctx->getSourceManager();
368   FileID FID = SM.getFileID(SM.getFileLoc(Loc));
369   if (FID.isInvalid())
370     return true;
371 
372   bool Invalid = false;
373   const SrcMgr::SLocEntry &SEntry = SM.getSLocEntry(FID, &Invalid);
374   if (Invalid || !SEntry.isFile())
375     return true;
376 
377   if (SEntry.getFile().getFileCharacteristic() != SrcMgr::C_User) {
378     switch (IndexOpts.SystemSymbolFilter) {
379     case IndexingOptions::SystemSymbolFilterKind::None:
380       return true;
381     case IndexingOptions::SystemSymbolFilterKind::DeclarationsOnly:
382       if (!shouldReportOccurrenceForSystemDeclOnlyMode(IsRef, Roles, Relations))
383         return true;
384       break;
385     case IndexingOptions::SystemSymbolFilterKind::All:
386       break;
387     }
388   }
389 
390   if (!OrigD)
391     OrigD = D;
392 
393   if (isTemplateImplicitInstantiation(D)) {
394     if (!IsRef)
395       return true;
396     D = adjustTemplateImplicitInstantiation(D);
397     if (!D)
398       return true;
399     assert(!isTemplateImplicitInstantiation(D));
400   }
401 
402   if (IsRef)
403     Roles |= (unsigned)SymbolRole::Reference;
404   else if (isDeclADefinition(OrigD, ContainerDC, *Ctx))
405     Roles |= (unsigned)SymbolRole::Definition;
406   else
407     Roles |= (unsigned)SymbolRole::Declaration;
408 
409   D = getCanonicalDecl(D);
410   Parent = adjustParent(Parent);
411   if (Parent)
412     Parent = getCanonicalDecl(Parent);
413 
414   SmallVector<SymbolRelation, 6> FinalRelations;
415   FinalRelations.reserve(Relations.size()+1);
416 
417   auto addRelation = [&](SymbolRelation Rel) {
418     auto It = llvm::find_if(FinalRelations, [&](SymbolRelation Elem) -> bool {
419       return Elem.RelatedSymbol == Rel.RelatedSymbol;
420     });
421     if (It != FinalRelations.end()) {
422       It->Roles |= Rel.Roles;
423     } else {
424       FinalRelations.push_back(Rel);
425     }
426     Roles |= Rel.Roles;
427   };
428 
429   if (Parent) {
430     if (IsRef || (!isa<ParmVarDecl>(D) && isFunctionLocalSymbol(D))) {
431       addRelation(SymbolRelation{
432         (unsigned)SymbolRole::RelationContainedBy,
433         Parent
434       });
435     } else {
436       addRelation(SymbolRelation{
437         (unsigned)SymbolRole::RelationChildOf,
438         Parent
439       });
440     }
441   }
442 
443   for (auto &Rel : Relations) {
444     addRelation(SymbolRelation(Rel.Roles,
445                                Rel.RelatedSymbol->getCanonicalDecl()));
446   }
447 
448   IndexDataConsumer::ASTNodeInfo Node{OrigE, OrigD, Parent, ContainerDC};
449   return DataConsumer.handleDeclOccurrence(D, Roles, FinalRelations, Loc, Node);
450 }
451 
452 void IndexingContext::handleMacroDefined(const IdentifierInfo &Name,
453                                          SourceLocation Loc,
454                                          const MacroInfo &MI) {
455   if (!shouldIndexMacroOccurrence(/*IsRef=*/false, Loc))
456     return;
457   SymbolRoleSet Roles = (unsigned)SymbolRole::Definition;
458   DataConsumer.handleMacroOccurrence(&Name, &MI, Roles, Loc);
459 }
460 
461 void IndexingContext::handleMacroUndefined(const IdentifierInfo &Name,
462                                            SourceLocation Loc,
463                                            const MacroInfo &MI) {
464   if (!shouldIndexMacroOccurrence(/*IsRef=*/false, Loc))
465     return;
466   SymbolRoleSet Roles = (unsigned)SymbolRole::Undefinition;
467   DataConsumer.handleMacroOccurrence(&Name, &MI, Roles, Loc);
468 }
469 
470 void IndexingContext::handleMacroReference(const IdentifierInfo &Name,
471                                            SourceLocation Loc,
472                                            const MacroInfo &MI) {
473   if (!shouldIndexMacroOccurrence(/*IsRef=*/true, Loc))
474     return;
475   SymbolRoleSet Roles = (unsigned)SymbolRole::Reference;
476   DataConsumer.handleMacroOccurrence(&Name, &MI, Roles, Loc);
477 }
478 
479 bool IndexingContext::shouldIndexMacroOccurrence(bool IsRef,
480                                                  SourceLocation Loc) {
481   if (!IndexOpts.IndexMacros)
482     return false;
483 
484   switch (IndexOpts.SystemSymbolFilter) {
485   case IndexingOptions::SystemSymbolFilterKind::None:
486     break;
487   case IndexingOptions::SystemSymbolFilterKind::DeclarationsOnly:
488     if (!IsRef)
489       return true;
490     break;
491   case IndexingOptions::SystemSymbolFilterKind::All:
492     return true;
493   }
494 
495   SourceManager &SM = Ctx->getSourceManager();
496   FileID FID = SM.getFileID(SM.getFileLoc(Loc));
497   if (FID.isInvalid())
498     return false;
499 
500   bool Invalid = false;
501   const SrcMgr::SLocEntry &SEntry = SM.getSLocEntry(FID, &Invalid);
502   if (Invalid || !SEntry.isFile())
503     return false;
504 
505   return SEntry.getFile().getFileCharacteristic() == SrcMgr::C_User;
506 }
507