13#include "clang/AST/ASTConcept.h"
14#include "clang/AST/ASTTypeTraits.h"
15#include "clang/AST/Decl.h"
16#include "clang/AST/DeclBase.h"
17#include "clang/AST/DeclCXX.h"
18#include "clang/AST/DeclTemplate.h"
19#include "clang/AST/DeclVisitor.h"
20#include "clang/AST/DeclarationName.h"
21#include "clang/AST/Expr.h"
22#include "clang/AST/ExprCXX.h"
23#include "clang/AST/ExprConcepts.h"
24#include "clang/AST/ExprObjC.h"
25#include "clang/AST/NestedNameSpecifier.h"
26#include "clang/AST/PrettyPrinter.h"
27#include "clang/AST/RecursiveASTVisitor.h"
28#include "clang/AST/StmtVisitor.h"
29#include "clang/AST/TemplateBase.h"
30#include "clang/AST/Type.h"
31#include "clang/AST/TypeLoc.h"
32#include "clang/AST/TypeLocVisitor.h"
33#include "clang/AST/TypeVisitor.h"
34#include "clang/Basic/LangOptions.h"
35#include "clang/Basic/SourceLocation.h"
36#include "clang/Basic/SourceManager.h"
37#include "clang/Basic/Specifiers.h"
38#include "llvm/ADT/STLExtras.h"
39#include "llvm/ADT/SmallVector.h"
40#include "llvm/ADT/StringExtras.h"
41#include "llvm/Support/Casting.h"
42#include "llvm/Support/Compiler.h"
43#include "llvm/Support/raw_ostream.h"
53LLVM_ATTRIBUTE_UNUSED std::string nodeToString(
const DynTypedNode &N) {
54 std::string S = std::string(N.getNodeKind().asStringRef());
56 llvm::raw_string_ostream
OS(S);
58 N.print(
OS, PrintingPolicy(LangOptions()));
60 std::replace(S.begin(), S.end(),
'\n',
' ');
64const NamedDecl *getTemplatePattern(
const NamedDecl *D) {
65 if (
const CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(D)) {
66 if (
const auto *Result = CRD->getTemplateInstantiationPattern())
71 if (CRD->getTemplateSpecializationKind() == TSK_Undeclared)
72 if (
const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(CRD))
73 return Spec->getSpecializedTemplate()->getTemplatedDecl();
74 }
else if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
75 return FD->getTemplateInstantiationPattern();
76 }
else if (
auto *VD = dyn_cast<VarDecl>(D)) {
78 VarDecl *T = VD->getTemplateInstantiationPattern();
79 return (T == D) ? nullptr : T;
80 }
else if (
const auto *ED = dyn_cast<EnumDecl>(D)) {
81 return ED->getInstantiatedFromMemberEnum();
82 }
else if (isa<FieldDecl>(D) || isa<TypedefNameDecl>(D)) {
83 if (
const auto *
Parent = llvm::dyn_cast<NamedDecl>(D->getDeclContext()))
84 if (
const DeclContext *ParentPat =
85 dyn_cast_or_null<DeclContext>(getTemplatePattern(
Parent)))
86 for (
const NamedDecl *BaseND : ParentPat->lookup(D->getDeclName()))
87 if (!BaseND->isImplicit() && BaseND->getKind() == D->getKind())
89 }
else if (
const auto *ECD = dyn_cast<EnumConstantDecl>(D)) {
90 if (
const auto *ED = dyn_cast<EnumDecl>(ECD->getDeclContext())) {
91 if (
const EnumDecl *Pattern = ED->getInstantiatedFromMemberEnum()) {
92 for (
const NamedDecl *BaseECD : Pattern->lookup(ECD->getDeclName()))
101bool shouldSkipTypedef(
const TypedefNameDecl *TD) {
104 if (TD == TD->getASTContext().getObjCInstanceTypeDecl() ||
105 TD == TD->getASTContext().getObjCIdDecl())
132 using RelSet = DeclRelationSet;
136 const HeuristicResolver *Resolver;
137 llvm::SmallDenseMap<
const NamedDecl *,
138 std::pair<RelSet,
size_t>>
140 llvm::SmallDenseMap<const Decl *, RelSet> Seen;
143 template <
typename T>
void debug(T &Node, RelSet Flags) {
144 dlog(
"visit [{0}] {1}", Flags, nodeToString(DynTypedNode::create(Node)));
147 void report(
const NamedDecl *D, RelSet Flags) {
148 dlog(
"--> [{0}] {1}", Flags, nodeToString(DynTypedNode::create(*D)));
149 auto It = Decls.try_emplace(D, std::make_pair(Flags, Decls.size()));
152 It.first->second.first |=
Flags;
156 TargetFinder(
const HeuristicResolver *Resolver) : Resolver(Resolver) {}
158 llvm::SmallVector<std::pair<const NamedDecl *, RelSet>, 1> takeDecls()
const {
159 using ValTy = std::pair<const NamedDecl *, RelSet>;
160 llvm::SmallVector<ValTy, 1> Result;
161 Result.resize(Decls.size());
162 for (
const auto &Elem : Decls)
163 Result[Elem.second.second] = {Elem.first, Elem.second.first};
167 void add(
const Decl *Dcl, RelSet Flags) {
168 const NamedDecl *D = llvm::dyn_cast_or_null<NamedDecl>(Dcl);
176 auto Res = Seen.try_emplace(D);
177 if (!Res.second && Res.first->second.contains(Flags))
179 Res.first->second |=
Flags;
181 if (
const UsingDirectiveDecl *UDD = llvm::dyn_cast<UsingDirectiveDecl>(D))
182 D = UDD->getNominatedNamespaceAsWritten();
184 if (
const TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(D)) {
185 add(TND->getUnderlyingType(), Flags | Rel::Underlying);
187 }
else if (
const UsingDecl *UD = dyn_cast<UsingDecl>(D)) {
189 for (
const UsingShadowDecl *S : UD->shadows())
190 add(S->getUnderlyingDecl(), Flags);
192 }
else if (
const UsingEnumDecl *UED = dyn_cast<UsingEnumDecl>(D)) {
194 D = UED->getEnumDecl();
195 }
else if (
const auto *NAD = dyn_cast<NamespaceAliasDecl>(D)) {
196 add(NAD->getUnderlyingDecl(), Flags | Rel::Underlying);
198 }
else if (
const UnresolvedUsingValueDecl *UUVD =
199 dyn_cast<UnresolvedUsingValueDecl>(D)) {
201 for (
const NamedDecl *Target : Resolver->resolveUsingValueDecl(UUVD)) {
206 }
else if (isa<UnresolvedUsingTypenameDecl>(D)) {
210 }
else if (
const UsingShadowDecl *USD = dyn_cast<UsingShadowDecl>(D)) {
215 if (llvm::isa<UsingDecl>(USD->getIntroducer()))
216 report(USD->getIntroducer(), Flags | Rel::Alias);
219 D = USD->getTargetDecl();
220 }
else if (
const auto *DG = dyn_cast<CXXDeductionGuideDecl>(D)) {
221 D = DG->getDeducedTemplate();
222 }
else if (
const ObjCImplementationDecl *IID =
223 dyn_cast<ObjCImplementationDecl>(D)) {
226 if (
const auto *CID = IID->getClassInterface())
227 if (
const auto *DD = CID->getDefinition())
228 if (!DD->isImplicitInterfaceDecl())
230 }
else if (
const ObjCCategoryImplDecl *CID =
231 dyn_cast<ObjCCategoryImplDecl>(D)) {
233 D = CID->getCategoryDecl();
238 if (
const Decl *Pat = getTemplatePattern(D)) {
240 add(Pat, Flags | Rel::TemplatePattern);
242 Flags |= Rel::TemplateInstantiation;
248 void add(
const Stmt *S, RelSet Flags) {
252 struct Visitor :
public ConstStmtVisitor<Visitor> {
255 Visitor(TargetFinder &Outer, RelSet
Flags) : Outer(Outer),
Flags(
Flags) {}
257 void VisitCallExpr(
const CallExpr *
CE) {
258 Outer.add(
CE->getCalleeDecl(),
Flags);
260 void VisitConceptSpecializationExpr(
const ConceptSpecializationExpr *
E) {
261 Outer.add(
E->getConceptReference(),
Flags);
263 void VisitDeclRefExpr(
const DeclRefExpr *DRE) {
264 const Decl *D = DRE->getDecl();
267 if (
auto *USD = llvm::dyn_cast<UsingShadowDecl>(DRE->getFoundDecl()))
271 void VisitMemberExpr(
const MemberExpr *ME) {
272 const Decl *D = ME->getMemberDecl();
274 llvm::dyn_cast<UsingShadowDecl>(ME->getFoundDecl().getDecl()))
278 void VisitOverloadExpr(
const OverloadExpr *OE) {
279 for (
auto *D : OE->decls())
282 void VisitSizeOfPackExpr(
const SizeOfPackExpr *SE) {
283 Outer.add(SE->getPack(),
Flags);
285 void VisitCXXConstructExpr(
const CXXConstructExpr *CCE) {
286 Outer.add(CCE->getConstructor(),
Flags);
288 void VisitDesignatedInitExpr(
const DesignatedInitExpr *DIE) {
289 for (
const DesignatedInitExpr::Designator &D :
290 llvm::reverse(DIE->designators()))
291 if (D.isFieldDesignator()) {
292 Outer.add(D.getFieldDecl(),
Flags);
297 void VisitGotoStmt(
const GotoStmt *Goto) {
298 if (
auto *LabelDecl = Goto->getLabel())
299 Outer.add(LabelDecl,
Flags);
301 void VisitLabelStmt(
const LabelStmt *
Label) {
302 if (
auto *LabelDecl =
Label->getDecl())
303 Outer.add(LabelDecl,
Flags);
306 VisitCXXDependentScopeMemberExpr(
const CXXDependentScopeMemberExpr *
E) {
307 if (Outer.Resolver) {
308 for (
const NamedDecl *D : Outer.Resolver->resolveMemberExpr(
E)) {
313 void VisitDependentScopeDeclRefExpr(
const DependentScopeDeclRefExpr *
E) {
314 if (Outer.Resolver) {
315 for (
const NamedDecl *D : Outer.Resolver->resolveDeclRefExpr(
E)) {
320 void VisitObjCIvarRefExpr(
const ObjCIvarRefExpr *OIRE) {
321 Outer.add(OIRE->getDecl(),
Flags);
323 void VisitObjCMessageExpr(
const ObjCMessageExpr *OME) {
324 Outer.add(OME->getMethodDecl(),
Flags);
326 void VisitObjCPropertyRefExpr(
const ObjCPropertyRefExpr *OPRE) {
327 if (OPRE->isExplicitProperty())
328 Outer.add(OPRE->getExplicitProperty(),
Flags);
330 if (OPRE->isMessagingGetter())
331 Outer.add(OPRE->getImplicitPropertyGetter(),
Flags);
332 if (OPRE->isMessagingSetter())
333 Outer.add(OPRE->getImplicitPropertySetter(),
Flags);
336 void VisitObjCProtocolExpr(
const ObjCProtocolExpr *OPE) {
337 Outer.add(OPE->getProtocol(),
Flags);
339 void VisitOpaqueValueExpr(
const OpaqueValueExpr *OVE) {
340 Outer.add(OVE->getSourceExpr(),
Flags);
342 void VisitPseudoObjectExpr(
const PseudoObjectExpr *POE) {
343 Outer.add(POE->getSyntacticForm(),
Flags);
345 void VisitCXXNewExpr(
const CXXNewExpr *CNE) {
346 Outer.add(CNE->getOperatorNew(),
Flags);
348 void VisitCXXDeleteExpr(
const CXXDeleteExpr *CDE) {
349 Outer.add(CDE->getOperatorDelete(),
Flags);
352 VisitCXXRewrittenBinaryOperator(
const CXXRewrittenBinaryOperator *RBO) {
353 Outer.add(RBO->getDecomposedForm().InnerBinOp,
Flags);
356 Visitor(*
this, Flags).Visit(S);
359 void add(QualType T, RelSet Flags) {
363 struct Visitor :
public TypeVisitor<Visitor> {
366 Visitor(TargetFinder &Outer, RelSet
Flags) : Outer(Outer),
Flags(
Flags) {}
368 void VisitTagType(
const TagType *TT) {
369 Outer.add(TT->getAsTagDecl(),
Flags);
372 void VisitElaboratedType(
const ElaboratedType *ET) {
373 Outer.add(ET->desugar(),
Flags);
376 void VisitUsingType(
const UsingType *ET) {
377 Outer.add(ET->getFoundDecl(),
Flags);
380 void VisitInjectedClassNameType(
const InjectedClassNameType *ICNT) {
381 Outer.add(ICNT->getDecl(),
Flags);
384 void VisitDecltypeType(
const DecltypeType *DTT) {
385 Outer.add(DTT->getUnderlyingType(),
Flags | Rel::Underlying);
390 Outer.add(DT->getDeducedType(),
Flags);
392 void VisitUnresolvedUsingType(
const UnresolvedUsingType *UUT) {
393 Outer.add(UUT->getDecl(),
Flags);
395 void VisitDeducedTemplateSpecializationType(
396 const DeducedTemplateSpecializationType *DTST) {
397 if (
const auto *USD = DTST->getTemplateName().getAsUsingShadowDecl())
398 Outer.add(USD,
Flags);
406 if (
auto *TD = DTST->getTemplateName().getAsTemplateDecl())
407 Outer.add(TD->getTemplatedDecl(),
Flags | Rel::TemplatePattern);
409 void VisitDependentNameType(
const DependentNameType *DNT) {
410 if (Outer.Resolver) {
411 for (
const NamedDecl *ND :
412 Outer.Resolver->resolveDependentNameType(DNT)) {
413 Outer.add(ND,
Flags);
417 void VisitDependentTemplateSpecializationType(
418 const DependentTemplateSpecializationType *DTST) {
419 if (Outer.Resolver) {
420 for (
const NamedDecl *ND :
421 Outer.Resolver->resolveTemplateSpecializationType(DTST)) {
422 Outer.add(ND,
Flags);
426 void VisitTypedefType(
const TypedefType *TT) {
427 if (shouldSkipTypedef(TT->getDecl()))
429 Outer.add(TT->getDecl(),
Flags);
432 VisitTemplateSpecializationType(
const TemplateSpecializationType *TST) {
435 if (
const auto *UTN = TST->getTemplateName().getAsUsingShadowDecl())
436 Outer.add(UTN,
Flags);
442 if (TST->isTypeAlias()) {
443 Outer.add(TST->getAliasedType(),
Flags | Rel::Underlying);
447 TST->getTemplateName().getAsTemplateDecl()->getTemplatedDecl(),
448 Flags | Rel::Alias | Rel::TemplatePattern);
452 else if (
const auto *
Parm =
453 llvm::dyn_cast_or_null<TemplateTemplateParmDecl>(
454 TST->getTemplateName().getAsTemplateDecl()))
457 else if (
const CXXRecordDecl *RD = TST->getAsCXXRecordDecl())
458 Outer.add(RD,
Flags);
461 if (
auto *TD = TST->getTemplateName().getAsTemplateDecl())
462 Outer.add(TD->getTemplatedDecl(),
Flags | Rel::TemplatePattern);
466 VisitSubstTemplateTypeParmType(
const SubstTemplateTypeParmType *STTPT) {
467 Outer.add(STTPT->getReplacementType(),
Flags);
469 void VisitTemplateTypeParmType(
const TemplateTypeParmType *TTPT) {
470 Outer.add(TTPT->getDecl(),
Flags);
472 void VisitObjCInterfaceType(
const ObjCInterfaceType *OIT) {
473 Outer.add(OIT->getDecl(),
Flags);
476 Visitor(*
this, Flags).Visit(T.getTypePtr());
479 void add(
const NestedNameSpecifier *NNS, RelSet Flags) {
483 switch (NNS->getKind()) {
484 case NestedNameSpecifier::Namespace:
485 add(NNS->getAsNamespace(), Flags);
487 case NestedNameSpecifier::NamespaceAlias:
488 add(NNS->getAsNamespaceAlias(), Flags);
490 case NestedNameSpecifier::Identifier:
492 add(QualType(Resolver->resolveNestedNameSpecifierToType(NNS), 0),
496 case NestedNameSpecifier::TypeSpec:
497 case NestedNameSpecifier::TypeSpecWithTemplate:
498 add(QualType(NNS->getAsType(), 0), Flags);
500 case NestedNameSpecifier::Global:
503 case NestedNameSpecifier::Super:
504 add(NNS->getAsRecordDecl(), Flags);
507 llvm_unreachable(
"unhandled NestedNameSpecifier::SpecifierKind");
510 void add(
const CXXCtorInitializer *CCI, RelSet Flags) {
515 if (CCI->isAnyMemberInitializer())
516 add(CCI->getAnyMember(), Flags);
520 void add(
const TemplateArgument &Arg, RelSet Flags) {
525 if (Arg.getKind() == TemplateArgument::Template ||
526 Arg.getKind() == TemplateArgument::TemplateExpansion) {
527 if (TemplateDecl *TD =
528 Arg.getAsTemplateOrTemplatePattern().getAsTemplateDecl()) {
531 if (
const auto *USD =
532 Arg.getAsTemplateOrTemplatePattern().getAsUsingShadowDecl())
537 void add(
const ConceptReference *CR, RelSet Flags) {
538 add(CR->getNamedConcept(), Flags);
544llvm::SmallVector<std::pair<const NamedDecl *, DeclRelationSet>, 1>
546 dlog(
"allTargetDecls({0})", nodeToString(N));
547 TargetFinder Finder(Resolver);
550 Finder.add(D,
Flags);
551 else if (
const Stmt *S = N.get<Stmt>())
552 Finder.add(S,
Flags);
553 else if (
const NestedNameSpecifierLoc *NNSL = N.get<NestedNameSpecifierLoc>())
554 Finder.add(NNSL->getNestedNameSpecifier(),
Flags);
555 else if (
const NestedNameSpecifier *NNS = N.get<NestedNameSpecifier>())
556 Finder.add(NNS,
Flags);
557 else if (
const TypeLoc *TL = N.get<TypeLoc>())
558 Finder.add(TL->getType(),
Flags);
559 else if (
const QualType *QT = N.get<QualType>())
560 Finder.add(*QT,
Flags);
561 else if (
const CXXCtorInitializer *CCI = N.get<CXXCtorInitializer>())
562 Finder.add(CCI,
Flags);
563 else if (
const TemplateArgumentLoc *TAL = N.get<TemplateArgumentLoc>())
564 Finder.add(TAL->getArgument(),
Flags);
565 else if (
const CXXBaseSpecifier *CBS = N.get<CXXBaseSpecifier>())
566 Finder.add(CBS->getTypeSourceInfo()->getType(),
Flags);
567 else if (
const ObjCProtocolLoc *PL = N.get<ObjCProtocolLoc>())
568 Finder.add(PL->getProtocol(),
Flags);
569 else if (
const ConceptReference *CR = N.get<ConceptReference>())
570 Finder.add(CR,
Flags);
571 return Finder.takeDecls();
574llvm::SmallVector<const NamedDecl *, 1>
577 llvm::SmallVector<const NamedDecl *, 1> Result;
579 if (!(
Entry.second & ~Mask))
580 Result.push_back(
Entry.first);
585llvm::SmallVector<const NamedDecl *, 1>
590 "explicitReferenceTargets handles templates on its own");
597 llvm::SmallVector<const NamedDecl *, 1> TemplatePatterns;
598 llvm::SmallVector<const NamedDecl *, 1> Targets;
599 bool SeenTemplateInstantiations =
false;
600 for (
auto &D : Decls) {
601 if (D.second & ~Mask)
604 TemplatePatterns.push_back(D.first);
608 SeenTemplateInstantiations =
true;
609 Targets.push_back(D.first);
611 if (!SeenTemplateInstantiations)
612 Targets.insert(Targets.end(), TemplatePatterns.begin(),
613 TemplatePatterns.end());
618llvm::SmallVector<ReferenceLoc> refInDecl(
const Decl *D,
619 const HeuristicResolver *Resolver) {
620 struct Visitor : ConstDeclVisitor<Visitor> {
621 Visitor(
const HeuristicResolver *Resolver) : Resolver(Resolver) {}
623 const HeuristicResolver *Resolver;
624 llvm::SmallVector<ReferenceLoc> Refs;
626 void VisitUsingDirectiveDecl(
const UsingDirectiveDecl *D) {
629 Refs.push_back(ReferenceLoc{D->getQualifierLoc(),
630 D->getIdentLocation(),
632 {D->getNominatedNamespaceAsWritten()}});
635 void VisitUsingDecl(
const UsingDecl *D) {
637 Refs.push_back(ReferenceLoc{
638 D->getQualifierLoc(), D->getLocation(),
false,
640 DeclRelation::Underlying, Resolver)});
643 void VisitUsingEnumDecl(
const UsingEnumDecl *D) {
649 void VisitNamespaceAliasDecl(
const NamespaceAliasDecl *D) {
654 Refs.push_back(ReferenceLoc{D->getQualifierLoc(),
655 D->getTargetNameLoc(),
657 {D->getAliasedNamespace()}});
660 void VisitNamedDecl(
const NamedDecl *ND) {
663 if (llvm::isa<ClassTemplateDecl>(ND) ||
664 llvm::isa<FunctionTemplateDecl>(ND) ||
665 llvm::isa<VarTemplateDecl>(ND) ||
666 llvm::isa<TypeAliasTemplateDecl>(ND))
669 if (llvm::isa<CXXDestructorDecl>(ND))
673 if (ND->getDeclName().isIdentifier() &&
674 !ND->getDeclName().getAsIdentifierInfo())
682 void VisitCXXDeductionGuideDecl(
const CXXDeductionGuideDecl *DG) {
685 Refs.push_back(ReferenceLoc{DG->getQualifierLoc(),
686 DG->getNameInfo().getLoc(),
688 {DG->getDeducedTemplate()}});
691 void VisitObjCMethodDecl(
const ObjCMethodDecl *OMD) {
693 Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
694 OMD->getSelectorStartLoc(),
699 void VisitObjCCategoryDecl(
const ObjCCategoryDecl *OCD) {
701 Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
704 {OCD->getClassInterface()}});
705 Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
706 OCD->getCategoryNameLoc(),
711 void VisitObjCCategoryImplDecl(
const ObjCCategoryImplDecl *OCID) {
712 Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
715 {OCID->getClassInterface()}});
716 Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
717 OCID->getCategoryNameLoc(),
719 {OCID->getCategoryDecl()}});
720 Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
721 OCID->getCategoryNameLoc(),
726 void VisitObjCImplementationDecl(
const ObjCImplementationDecl *OIMD) {
727 Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
730 {OIMD->getClassInterface()}});
731 Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
743llvm::SmallVector<ReferenceLoc> refInStmt(
const Stmt *S,
744 const HeuristicResolver *Resolver) {
745 struct Visitor : ConstStmtVisitor<Visitor> {
746 Visitor(
const HeuristicResolver *Resolver) : Resolver(Resolver) {}
748 const HeuristicResolver *Resolver;
750 llvm::SmallVector<ReferenceLoc> Refs;
752 void VisitDeclRefExpr(
const DeclRefExpr *
E) {
753 Refs.push_back(ReferenceLoc{
E->getQualifierLoc(),
754 E->getNameInfo().getLoc(),
756 {E->getFoundDecl()}});
759 void VisitDependentScopeDeclRefExpr(
const DependentScopeDeclRefExpr *
E) {
760 Refs.push_back(ReferenceLoc{
761 E->getQualifierLoc(),
E->getNameInfo().getLoc(),
false,
765 void VisitMemberExpr(
const MemberExpr *
E) {
768 if (llvm::isa<CXXDestructorDecl>(
E->getFoundDecl().getDecl()))
770 Refs.push_back(ReferenceLoc{
E->getQualifierLoc(),
771 E->getMemberNameInfo().getLoc(),
773 {E->getFoundDecl()}});
777 VisitCXXDependentScopeMemberExpr(
const CXXDependentScopeMemberExpr *
E) {
778 Refs.push_back(ReferenceLoc{
779 E->getQualifierLoc(),
E->getMemberNameInfo().getLoc(),
784 void VisitOverloadExpr(
const OverloadExpr *
E) {
785 Refs.push_back(ReferenceLoc{
E->getQualifierLoc(),
786 E->getNameInfo().getLoc(),
788 llvm::SmallVector<const NamedDecl *, 1>(
789 E->decls().begin(),
E->decls().end())});
792 void VisitSizeOfPackExpr(
const SizeOfPackExpr *
E) {
793 Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
799 void VisitObjCPropertyRefExpr(
const ObjCPropertyRefExpr *
E) {
800 Refs.push_back(ReferenceLoc{
801 NestedNameSpecifierLoc(),
E->getLocation(),
807 void VisitObjCIvarRefExpr(
const ObjCIvarRefExpr *OIRE) {
808 Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
814 void VisitObjCMessageExpr(
const ObjCMessageExpr *
E) {
816 Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
817 E->getSelectorStartLoc(),
819 {
E->getMethodDecl()}});
822 void VisitDesignatedInitExpr(
const DesignatedInitExpr *DIE) {
823 for (
const DesignatedInitExpr::Designator &D : DIE->designators()) {
824 if (!D.isFieldDesignator())
827 Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
830 {D.getFieldDecl()}});
834 void VisitGotoStmt(
const GotoStmt *GS) {
835 Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
841 void VisitLabelStmt(
const LabelStmt *LS) {
842 Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
854llvm::SmallVector<ReferenceLoc>
855refInTypeLoc(TypeLoc L,
const HeuristicResolver *Resolver) {
856 struct Visitor : TypeLocVisitor<Visitor> {
857 Visitor(
const HeuristicResolver *Resolver) : Resolver(Resolver) {}
859 const HeuristicResolver *Resolver;
860 llvm::SmallVector<ReferenceLoc> Refs;
862 void VisitElaboratedTypeLoc(ElaboratedTypeLoc L) {
864 size_t InitialSize = Refs.size();
865 Visit(L.getNamedTypeLoc().getUnqualifiedLoc());
866 size_t NewSize = Refs.size();
868 for (
unsigned I = InitialSize; I < NewSize; ++I) {
869 ReferenceLoc *Ref = &Refs[I];
871 assert(!Ref->Qualifier.hasQualifier() &&
"qualifier already set");
872 Ref->Qualifier = L.getQualifierLoc();
876 void VisitUsingTypeLoc(UsingTypeLoc L) {
877 Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
878 L.getLocalSourceRange().getBegin(),
880 {L.getFoundDecl()}});
883 void VisitTagTypeLoc(TagTypeLoc L) {
884 Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
890 void VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc L) {
891 Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
897 void VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc L) {
906 Refs.push_back(ReferenceLoc{
907 NestedNameSpecifierLoc(), L.getTemplateNameLoc(),
false,
909 DeclRelation::Alias, Resolver)});
911 void VisitDeducedTemplateSpecializationTypeLoc(
912 DeducedTemplateSpecializationTypeLoc L) {
913 Refs.push_back(ReferenceLoc{
914 NestedNameSpecifierLoc(), L.getNameLoc(),
false,
916 DeclRelation::Alias, Resolver)});
919 void VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
920 Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
926 void VisitDependentTemplateSpecializationTypeLoc(
927 DependentTemplateSpecializationTypeLoc L) {
929 ReferenceLoc{L.getQualifierLoc(), L.getTemplateNameLoc(),
932 DynTypedNode::create(L.getType()), {}, Resolver)});
935 void VisitDependentNameTypeLoc(DependentNameTypeLoc L) {
937 ReferenceLoc{L.getQualifierLoc(), L.getNameLoc(),
940 DynTypedNode::create(L.getType()), {}, Resolver)});
943 void VisitTypedefTypeLoc(TypedefTypeLoc L) {
944 if (shouldSkipTypedef(L.getTypedefNameDecl()))
946 Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
949 {L.getTypedefNameDecl()}});
952 void VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc L) {
953 Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
956 {L.getIFaceDecl()}});
961 V.Visit(L.getUnqualifiedLoc());
965class ExplicitReferenceCollector
968 ExplicitReferenceCollector(llvm::function_ref<
void(ReferenceLoc)> Out,
969 const HeuristicResolver *Resolver)
970 :
Out(
Out), Resolver(Resolver) {
974 bool VisitTypeLoc(TypeLoc TTL) {
975 if (TypeLocsToSkip.count(TTL.getBeginLoc()))
977 visitNode(DynTypedNode::create(TTL));
981 bool TraverseElaboratedTypeLoc(ElaboratedTypeLoc L) {
984 TypeLoc
Inner = L.getNamedTypeLoc().getUnqualifiedLoc();
985 if (L.getBeginLoc() ==
Inner.getBeginLoc())
986 return RecursiveASTVisitor::TraverseTypeLoc(
Inner);
988 TypeLocsToSkip.insert(
Inner.getBeginLoc());
989 return RecursiveASTVisitor::TraverseElaboratedTypeLoc(L);
992 bool VisitStmt(Stmt *S) {
993 visitNode(DynTypedNode::create(*S));
997 bool TraverseOpaqueValueExpr(OpaqueValueExpr *OVE) {
998 visitNode(DynTypedNode::create(*OVE));
1001 return RecursiveASTVisitor::TraverseStmt(OVE->getSourceExpr());
1004 bool TraversePseudoObjectExpr(PseudoObjectExpr *POE) {
1005 visitNode(DynTypedNode::create(*POE));
1008 return RecursiveASTVisitor::TraverseStmt(POE->getSyntacticForm());
1014 bool TraverseTemplateArgumentLoc(TemplateArgumentLoc A) {
1015 switch (
A.getArgument().getKind()) {
1016 case TemplateArgument::Template:
1017 case TemplateArgument::TemplateExpansion:
1018 reportReference(ReferenceLoc{
A.getTemplateQualifierLoc(),
1019 A.getTemplateNameLoc(),
1022 .getAsTemplateOrTemplatePattern()
1023 .getAsTemplateDecl()}},
1024 DynTypedNode::create(
A.getArgument()));
1026 case TemplateArgument::Declaration:
1028 case TemplateArgument::Integral:
1029 case TemplateArgument::Null:
1030 case TemplateArgument::NullPtr:
1032 case TemplateArgument::Pack:
1033 case TemplateArgument::Type:
1034 case TemplateArgument::Expression:
1037 return RecursiveASTVisitor::TraverseTemplateArgumentLoc(A);
1040 bool VisitDecl(
Decl *D) {
1041 visitNode(DynTypedNode::create(*D));
1046 bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc L) {
1047 if (!L.getNestedNameSpecifier())
1049 visitNode(DynTypedNode::create(L));
1051 if (
auto TL = L.getTypeLoc())
1052 TypeLocsToSkip.insert(TL.getBeginLoc());
1053 return RecursiveASTVisitor::TraverseNestedNameSpecifierLoc(L);
1056 bool TraverseObjCProtocolLoc(ObjCProtocolLoc ProtocolLoc) {
1057 visitNode(DynTypedNode::create(ProtocolLoc));
1061 bool TraverseConstructorInitializer(CXXCtorInitializer *Init) {
1062 visitNode(DynTypedNode::create(*Init));
1063 return RecursiveASTVisitor::TraverseConstructorInitializer(Init);
1066 bool VisitConceptReference(
const ConceptReference *CR) {
1067 visitNode(DynTypedNode::create(*CR));
1086 llvm::SmallVector<ReferenceLoc> explicitReference(DynTypedNode N) {
1087 if (
auto *D = N.get<
Decl>())
1088 return refInDecl(D, Resolver);
1089 if (
auto *S = N.get<Stmt>())
1090 return refInStmt(S, Resolver);
1091 if (
auto *NNSL = N.get<NestedNameSpecifierLoc>()) {
1093 return {ReferenceLoc{
1094 NNSL->getPrefix(), NNSL->getLocalBeginLoc(),
false,
1096 DynTypedNode::create(*NNSL->getNestedNameSpecifier()),
1099 if (
const TypeLoc *TL = N.get<TypeLoc>())
1100 return refInTypeLoc(*TL, Resolver);
1101 if (
const CXXCtorInitializer *CCI = N.get<CXXCtorInitializer>()) {
1104 if (CCI->isAnyMemberInitializer()) {
1105 return {ReferenceLoc{NestedNameSpecifierLoc(),
1106 CCI->getMemberLocation(),
1108 {CCI->getAnyMember()}}};
1111 if (
const ObjCProtocolLoc *PL = N.get<ObjCProtocolLoc>())
1112 return {ReferenceLoc{NestedNameSpecifierLoc(),
1115 {PL->getProtocol()}}};
1116 if (
const ConceptReference *CR = N.get<ConceptReference>())
1117 return {ReferenceLoc{CR->getNestedNameSpecifierLoc(),
1118 CR->getConceptNameLoc(),
1120 {CR->getNamedConcept()}}};
1126 void visitNode(DynTypedNode N) {
1127 for (
auto &R : explicitReference(N))
1128 reportReference(std::move(R), N);
1131 void reportReference(ReferenceLoc &&Ref, DynTypedNode N) {
1134 llvm::erase(Ref.Targets,
nullptr);
1139 if (Ref.NameLoc.isInvalid()) {
1140 dlog(
"invalid location at node {0}", nodeToString(N));
1146 llvm::function_ref<void(ReferenceLoc)>
Out;
1147 const HeuristicResolver *Resolver;
1150 llvm::DenseSet<SourceLocation> TypeLocsToSkip;
1158 ExplicitReferenceCollector(
Out, Resolver).TraverseStmt(
const_cast<Stmt *
>(S));
1164 ExplicitReferenceCollector(
Out, Resolver).TraverseDecl(
const_cast<Decl *
>(D));
1169 ExplicitReferenceCollector(
Out, Resolver)
1170 .TraverseAST(
const_cast<ASTContext &
>(
AST));
1175#define REL_CASE(X) \
1176 case DeclRelation::X: \
1184 llvm_unreachable(
"Unhandled DeclRelation enum");
1187 const char *Sep =
"";
1188 for (
unsigned I = 0; I < RS.S.size(); ++I) {
1190 OS << Sep << static_cast<DeclRelation>(I);
1199 OS <<
"targets = {";
1200 llvm::SmallVector<std::string> Targets;
1201 for (
const NamedDecl *T : R.
Targets) {
1202 llvm::raw_string_ostream Target(Targets.emplace_back());
1205 llvm::sort(Targets);
1206 OS << llvm::join(Targets,
", ");
1209 OS <<
", qualifier = '";
1211 PrintingPolicy(LangOptions()));
const FunctionDecl * Decl
std::pair< Context, Canceler > Inner
CompiledFragmentImpl & Out
llvm::raw_string_ostream OS
std::string printTemplateSpecializationArgs(const NamedDecl &ND)
Prints template arguments of a decl as written in the source code, including enclosing '<' and '>',...
llvm::SmallVector< std::pair< const NamedDecl *, DeclRelationSet >, 1 > allTargetDecls(const DynTypedNode &N, const HeuristicResolver *Resolver)
Similar to targetDecl(), however instead of applying a filter, all possible decls are returned along ...
llvm::SmallVector< const NamedDecl *, 1 > explicitReferenceTargets(DynTypedNode N, DeclRelationSet Mask, const HeuristicResolver *Resolver)
Find declarations explicitly referenced in the source code defined by N.
void findExplicitReferences(const Stmt *S, llvm::function_ref< void(ReferenceLoc)> Out, const HeuristicResolver *Resolver)
Recursively traverse S and report all references explicitly written in the code.
NestedNameSpecifierLoc getQualifierLoc(const NamedDecl &ND)
Returns a nested name specifier loc of ND if it was present in the source, e.g.
llvm::SmallVector< const NamedDecl *, 1 > targetDecl(const DynTypedNode &N, DeclRelationSet Mask, const HeuristicResolver *Resolver)
targetDecl() finds the declaration referred to by an AST node.
llvm::raw_ostream & operator<<(llvm::raw_ostream &OS, const CodeCompletion &C)
std::string printQualifiedName(const NamedDecl &ND)
Returns the qualified name of ND.
@ Underlying
This is the underlying declaration for a renaming-alias, decltype etc.
@ TemplatePattern
This is the pattern the template specialization was instantiated from.
@ TemplateInstantiation
This is the template instantiation that was referred to.
@ Alias
This declaration is an alias that was referred to.
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Information about a reference written in the source code, independent of the actual AST node that thi...
NestedNameSpecifierLoc Qualifier
Contains qualifier written in the code, if any, e.g. 'ns::' for 'ns::foo'.
bool IsDecl
True if the reference is a declaration or definition;.
llvm::SmallVector< const NamedDecl *, 1 > Targets
A list of targets referenced by this name.