clang: lib/AST/DeclPrinter.cpp Source File (original) (raw)
1
2
3
4
5
6
7
8
9
10
11
12
25#include "llvm/Support/raw_ostream.h"
26using namespace clang;
27
28namespace {
29 class DeclPrinter : public DeclVisitor {
30 raw_ostream &Out;
33 unsigned Indentation;
34 bool PrintInstantiation;
35
36 raw_ostream& Indent() { return Indent(Indentation); }
37 raw_ostream& Indent(unsigned Indentation);
39
42 std::string &Proto);
43
44
45
46
47
50
52
53 public:
54 DeclPrinter(raw_ostream &Out, const PrintingPolicy &Policy,
55 const ASTContext &Context, unsigned Indentation = 0,
56 bool PrintInstantiation = false)
57 : Out(Out), Policy(Policy), Context(Context), Indentation(Indentation),
58 PrintInstantiation(PrintInstantiation) {}
59
60 void VisitDeclContext(DeclContext *DC, bool Indent = true);
61
72 void VisitVarDecl(VarDecl *D);
87 void VisitClassTemplateSpecializationDecl(
89 void VisitClassTemplatePartialSpecializationDecl(
114
116 bool OmitTemplateKW = false);
122 bool
123 prettyPrintAttributes(const Decl *D,
124 AttrPosAsWritten Pos = AttrPosAsWritten::Default);
125 void prettyPrintPragmas(Decl *D);
126 void printDeclType(QualType T, StringRef DeclName, bool Pack = false);
127 };
128}
129
130void Decl::print(raw_ostream &Out, unsigned Indentation,
131 bool PrintInstantiation) const {
132 print(Out, getASTContext().getPrintingPolicy(), Indentation, PrintInstantiation);
133}
134
136 unsigned Indentation, bool PrintInstantiation) const {
137 DeclPrinter Printer(Out, Policy, getASTContext(), Indentation,
138 PrintInstantiation);
139 Printer.Visit(const_cast<Decl*>(this));
140}
141
143 bool OmitTemplateKW) const {
145}
146
149 bool OmitTemplateKW) const {
150 DeclPrinter Printer(Out, Policy, Context);
151 Printer.printTemplateParameters(this, OmitTemplateKW);
152}
153
155
165 else if (const ArrayType *ATy = dyn_cast(BaseType))
166 BaseType = ATy->getElementType();
168 BaseType = FTy->getReturnType();
170 BaseType = VTy->getElementType();
174 BaseType = ATy->getDeducedType();
176 BaseType = PTy->desugar();
177 else
178
179 break;
180 }
181 return BaseType;
182}
183
186 return TDD->getUnderlyingType();
187 if (ValueDecl* VD = dyn_cast(D))
188 return VD->getType();
190}
191
194 unsigned Indentation) {
195 if (NumDecls == 1) {
196 (*Begin)->print(Out, Policy, Indentation);
197 return;
198 }
199
202 if (TD)
204
206
207 bool isFirst = true;
209 if (isFirst) {
210 if(TD)
213 isFirst = false;
214 } else {
215 if (!isFirst) Out << ", ";
218 }
219
220 (*Begin)->print(Out, SubPolicy, Indentation);
221 }
222}
223
225
229
230 ASTContext &Ctx = cast(DC)->getASTContext();
231 DeclPrinter Printer(llvm::errs(), Ctx.getPrintingPolicy(), Ctx, 0);
232 Printer.VisitDeclContext(const_cast<DeclContext *>(this), false);
233}
234
235raw_ostream& DeclPrinter::Indent(unsigned Indentation) {
236 for (unsigned i = 0; i != Indentation; ++i)
237 Out << " ";
238 return Out;
239}
240
247 return DeclPrinter::AttrPosAsWritten::Left;
248
249 if (C.getSourceManager().isBeforeInTranslationUnit(ALoc, DLoc))
250 return DeclPrinter::AttrPosAsWritten::Left;
251
252 return DeclPrinter::AttrPosAsWritten::Right;
253}
254
255
256bool DeclPrinter::prettyPrintAttributes(const Decl *D,
257 AttrPosAsWritten Pos ) {
258 bool hasPrinted = false;
259
262 for (auto *A : Attrs) {
263 if (A->isInherited() || A->isImplicit())
264 continue;
265
267 continue;
268 switch (A->getKind()) {
269#define ATTR(X)
270#define PRAGMA_SPELLING_ATTR(X) case attr::X:
271#include "clang/Basic/AttrList.inc"
272 break;
273 default:
275 assert(APos != AttrPosAsWritten::Default &&
276 "Default not a valid for an attribute location");
277 if (Pos == AttrPosAsWritten::Default || Pos == APos) {
278 if (Pos != AttrPosAsWritten::Left)
279 Out << ' ';
280 A->printPretty(Out, Policy);
281 hasPrinted = true;
282 if (Pos == AttrPosAsWritten::Left)
283 Out << ' ';
284 }
285 break;
286 }
287 }
288 }
289 return hasPrinted;
290}
291
292void DeclPrinter::prettyPrintPragmas(Decl *D) {
294 return;
295
298 for (auto *A : Attrs) {
299 switch (A->getKind()) {
300#define ATTR(X)
301#define PRAGMA_SPELLING_ATTR(X) case attr::X:
302#include "clang/Basic/AttrList.inc"
303 A->printPretty(Out, Policy);
304 Indent();
305 break;
306 default:
307 break;
308 }
309 }
310 }
311}
312
313void DeclPrinter::printDeclType(QualType T, StringRef DeclName, bool Pack) {
314
315
316
318 Pack = true;
319 T = PET->getPattern();
320 }
321 T.print(Out, Policy, (Pack ? "..." : "") + DeclName, Indentation);
322}
323
325 this->Indent();
326 Decl::printGroup(Decls.data(), Decls.size(), Out, Policy, Indentation);
327 Out << ";\n";
328 Decls.clear();
329
330}
331
334 if (AccessSpelling.empty())
335 llvm_unreachable("No access specifier!");
336 Out << AccessSpelling;
337}
338
339void DeclPrinter::PrintConstructorInitializers(CXXConstructorDecl *CDecl,
340 std::string &Proto) {
341 bool HasInitializerList = false;
342 for (const auto *BMInitializer : CDecl->inits()) {
343 if (BMInitializer->isInClassMemberInitializer())
344 continue;
345 if (!BMInitializer->isWritten())
346 continue;
347
348 if (!HasInitializerList) {
349 Proto += " : ";
350 Out << Proto;
351 Proto.clear();
352 HasInitializerList = true;
353 } else
354 Out << ", ";
355
356 if (BMInitializer->isAnyMemberInitializer()) {
357 FieldDecl *FD = BMInitializer->getAnyMember();
358 Out << *FD;
359 } else if (BMInitializer->isDelegatingInitializer()) {
361 } else {
363 }
364
365 if (Expr *Init = BMInitializer->getInit()) {
366 bool OutParens = !isa(Init);
367
368 if (OutParens)
369 Out << "(";
370
372 Init = Tmp->getSubExpr();
373
375
376 Expr *SimpleInit = nullptr;
377 Expr **Args = nullptr;
378 unsigned NumArgs = 0;
380 Args = ParenList->getExprs();
381 NumArgs = ParenList->getNumExprs();
383 dyn_cast(Init)) {
384 Args = Construct->getArgs();
385 NumArgs = Construct->getNumArgs();
386 } else
387 SimpleInit = Init;
388
389 if (SimpleInit)
390 SimpleInit->printPretty(Out, nullptr, Policy, Indentation, "\n",
391 &Context);
392 else {
393 for (unsigned I = 0; I != NumArgs; ++I) {
394 assert(Args[I] != nullptr && "Expected non-null Expr");
395 if (isa(Args[I]))
396 break;
397
398 if (I)
399 Out << ", ";
400 Args[I]->printPretty(Out, nullptr, Policy, Indentation, "\n",
401 &Context);
402 }
403 }
404
405 if (OutParens)
406 Out << ")";
407 } else {
408 Out << "()";
409 }
410
411 if (BMInitializer->isPackExpansion())
412 Out << "...";
413 }
414}
415
416
417
418
419
420void DeclPrinter::VisitDeclContext(DeclContext *DC, bool Indent) {
422 return;
423
424 if (Indent)
426
430
431
432
433 if (isa(*D))
434 continue;
435
436
438 continue;
439
440
441
442 if (auto FD = dyn_cast(*D))
444 !isa(DC))
445 continue;
446
447
448
449
450
451
452
453
454
455
456
457
458
460 if (!Decls.empty() && !CurDeclType.isNull()) {
462 if (!BaseType.isNull() && isa(BaseType) &&
463 cast(BaseType)->getOwnedTagDecl() == Decls[0]) {
464 Decls.push_back(*D);
465 continue;
466 }
467 }
468
469
470 if (!Decls.empty())
471 ProcessDeclGroup(Decls);
472
473
474
475 if (isa(*D) && !cast(*D)->isFreeStanding()) {
476 Decls.push_back(*D);
477 continue;
478 }
479
480 if (isa(*D)) {
482 this->Indent();
484 Out << ":\n";
486 continue;
487 }
488
489 this->Indent();
490 Visit(*D);
491
492
493 const char *Terminator = nullptr;
496 isa(*D))
497 Terminator = nullptr;
498 else if (isa(*D) && cast(*D)->hasBody())
499 Terminator = nullptr;
500 else if (auto FD = dyn_cast(*D)) {
501 if (FD->doesThisDeclarationHaveABody() && !FD->isDefaulted())
502 Terminator = nullptr;
503 else
504 Terminator = ";";
505 } else if (auto TD = dyn_cast(*D)) {
506 if (TD->getTemplatedDecl()->doesThisDeclarationHaveABody())
507 Terminator = nullptr;
508 else
509 Terminator = ";";
513 Terminator = nullptr;
514 else if (isa(*D)) {
516 ++Next;
517 if (Next != DEnd)
518 Terminator = ",";
519 } else
520 Terminator = ";";
521
522 if (Terminator)
523 Out << Terminator;
525 ((isa(*D) &&
526 cast(*D)->doesThisDeclarationHaveABody()) ||
527 (isa(*D) &&
528 cast(*D)->getTemplatedDecl()->doesThisDeclarationHaveABody())))
529 ;
530 else
531 Out << "\n";
532
533
534
536 Out << "#pragma omp end declare target\n";
537 }
538
539 if (!Decls.empty())
540 ProcessDeclGroup(Decls);
541
542 if (Indent)
544}
545
547 VisitDeclContext(D, false);
548}
549
550void DeclPrinter::VisitTypedefDecl(TypedefDecl *D) {
552 Out << "typedef ";
553
555 Out << "__module_private__ ";
556 }
557 QualType Ty = D->getTypeSourceInfo()->getType();
558 Ty.print(Out, Policy, D->getName(), Indentation);
559 prettyPrintAttributes(D);
560}
561
562void DeclPrinter::VisitTypeAliasDecl(TypeAliasDecl *D) {
563 Out << "using " << *D;
564 prettyPrintAttributes(D);
565 Out << " = " << D->getTypeSourceInfo()->getType().getAsString(Policy);
566}
567
568void DeclPrinter::VisitEnumDecl(EnumDecl *D) {
570 Out << "__module_private__ ";
571 Out << "enum";
572 if (D->isScoped()) {
573 if (D->isScopedUsingClassTag())
574 Out << " class";
575 else
576 Out << " struct";
577 }
578
579 prettyPrintAttributes(D);
580
581 if (D->getDeclName())
582 Out << ' ' << D->getDeclName();
583
584 if (D->isFixed())
585 Out << " : " << D->getIntegerType().stream(Policy);
586
587 if (D->isCompleteDefinition()) {
588 Out << " {\n";
589 VisitDeclContext(D);
590 Indent() << "}";
591 }
592}
593
594void DeclPrinter::VisitRecordDecl(RecordDecl *D) {
596 Out << "__module_private__ ";
597 Out << D->getKindName();
598
599 prettyPrintAttributes(D);
600
601 if (D->getIdentifier())
602 Out << ' ' << *D;
603
604 if (D->isCompleteDefinition()) {
605 Out << " {\n";
606 VisitDeclContext(D);
607 Indent() << "}";
608 }
609}
610
612 Out << *D;
613 prettyPrintAttributes(D);
614 if (Expr *Init = D->getInitExpr()) {
615 Out << " = ";
616 Init->printPretty(Out, nullptr, Policy, Indentation, "\n", &Context);
617 }
618}
619
623 std::string Proto = "explicit";
624 llvm::raw_string_ostream EOut(Proto);
626 EOut << "(";
628 &Context);
629 EOut << ")";
630 }
631 EOut << " ";
632 Out << Proto;
633}
634
637 llvm::raw_ostream &Out) {
638 StringRef prefix = T->isClassType() ? "class "
641 : "";
642 Out << prefix;
643}
644
645void DeclPrinter::VisitFunctionDecl(FunctionDecl *D) {
646 if (->getDescribedFunctionTemplate() &&
647 ->isFunctionTemplateSpecialization()) {
648 prettyPrintPragmas(D);
649 prettyPrintAttributes(D, AttrPosAsWritten::Left);
650 }
651
652 if (D->isFunctionTemplateSpecialization())
653 Out << "template<> ";
654 else if (->getDescribedFunctionTemplate()) {
655 for (unsigned I = 0, NumTemplateParams = D->getNumTemplateParameterLists();
656 I < NumTemplateParams; ++I)
657 printTemplateParameters(D->getTemplateParameterList(I));
658 }
659
664 switch (D->getStorageClass()) {
666 case SC_Extern: Out << "extern "; break;
667 case SC_Static: Out << "static "; break;
670 llvm_unreachable("invalid for functions");
671 }
672
673 if (D->isInlineSpecified()) Out << "inline ";
674 if (D->isVirtualAsWritten()) Out << "virtual ";
676 if (D->isConstexprSpecified() && ->isExplicitlyDefaulted())
677 Out << "constexpr ";
678 if (D->isConsteval()) Out << "consteval ";
679 else if (D->isImmediateFunction())
680 Out << "immediate ";
684 }
685
687 SubPolicy.SuppressSpecifiers = false;
688 std::string Proto;
689
691 Proto += D->getQualifiedNameAsString();
692 } else {
693 llvm::raw_string_ostream OS(Proto);
696 NS->print(OS, Policy);
697 }
698 }
699 D->getNameInfo().printName(OS, Policy);
700 }
701
702 if (GuideDecl)
704 if (D->isFunctionTemplateSpecialization()) {
705 llvm::raw_string_ostream POut(Proto);
706 DeclPrinter TArgPrinter(POut, SubPolicy, Context, Indentation);
707 const auto *TArgAsWritten = D->getTemplateSpecializationArgsAsWritten();
709 TArgPrinter.printTemplateArguments(TArgAsWritten->arguments(), nullptr);
711 D->getTemplateSpecializationArgs())
712 TArgPrinter.printTemplateArguments(TArgs->asArray(), nullptr);
713 }
714
716 while (const ParenType *PT = dyn_cast(Ty)) {
717 Proto = '(' + Proto + ')';
718 Ty = PT->getInnerType();
719 }
720
723 if (D->hasWrittenPrototype())
724 FT = dyn_cast(AFT);
725
726 Proto += "(";
727 if (FT) {
728 llvm::raw_string_ostream POut(Proto);
729 DeclPrinter ParamPrinter(POut, SubPolicy, Context, Indentation);
730 for (unsigned i = 0, e = D->getNumParams(); i != e; ++i) {
731 if (i) POut << ", ";
732 ParamPrinter.VisitParmVarDecl(D->getParamDecl(i));
733 }
734
736 if (D->getNumParams()) POut << ", ";
737 POut << "...";
738 } else if (->getNumParams() && !Context.getLangOpts().CPlusPlus) {
739
740
741 POut << "void";
742 }
743 } else if (D->doesThisDeclarationHaveABody() && ->hasPrototype()) {
744 for (unsigned i = 0, e = D->getNumParams(); i != e; ++i) {
745 if (i)
746 Proto += ", ";
747 Proto += D->getParamDecl(i)->getNameAsString();
748 }
749 }
750
751 Proto += ")";
752
753 if (FT) {
755 Proto += " const";
757 Proto += " volatile";
759 Proto += " restrict";
760
763 break;
765 Proto += " &";
766 break;
768 Proto += " &&";
769 break;
770 }
771 }
772
774 Proto += " throw(";
776 Proto += "...";
777 else
778 for (unsigned I = 0, N = FT->getNumExceptions(); I != N; ++I) {
779 if (I)
780 Proto += ", ";
781
783 }
784 Proto += ")";
786 Proto += " noexcept";
788 Proto += "(";
789 llvm::raw_string_ostream EOut(Proto);
791 Indentation, "\n", &Context);
792 Proto += ")";
793 }
794 }
795
796 if (CDecl) {
798 PrintConstructorInitializers(CDecl, Proto);
799 } else if (!ConversionDecl && !isa(D)) {
801 if (!GuideDecl)
802 Out << "auto ";
803 Out << Proto << " -> ";
804 Proto.clear();
805 }
809 Out);
810 AFT->getReturnType().print(Out, Policy, Proto);
811 Proto.clear();
812 }
813 Out << Proto;
814
815 if (Expr *TrailingRequiresClause = D->getTrailingRequiresClause()) {
816 Out << " requires ";
817 TrailingRequiresClause->printPretty(Out, nullptr, SubPolicy, Indentation,
818 "\n", &Context);
819 }
820 } else {
821 Ty.print(Out, Policy, Proto);
822 }
823
824 prettyPrintAttributes(D, AttrPosAsWritten::Right);
825
826 if (D->isPureVirtual())
827 Out << " = 0";
828 else if (D->isDeletedAsWritten()) {
829 Out << " = delete";
830 if (const StringLiteral *M = D->getDeletedMessage()) {
831 Out << "(";
832 M->outputString(Out);
833 Out << ")";
834 }
835 } else if (D->isExplicitlyDefaulted())
836 Out << " = default";
837 else if (D->doesThisDeclarationHaveABody()) {
839 if (->hasPrototype() && D->getNumParams()) {
840
841
842 Out << '\n';
843 DeclPrinter ParamPrinter(Out, SubPolicy, Context, Indentation);
845 for (unsigned i = 0, e = D->getNumParams(); i != e; ++i) {
846 Indent();
847 ParamPrinter.VisitParmVarDecl(D->getParamDecl(i));
848 Out << ";\n";
849 }
851 }
852
855 &Context);
856 } else {
857 if (!Policy.TerseOutput && isa(*D))
858 Out << " {}";
859 }
860 }
861}
862
863void DeclPrinter::VisitFriendDecl(FriendDecl *D) {
865 unsigned NumTPLists = D->getFriendTypeNumTemplateParameterLists();
866 for (unsigned i = 0; i < NumTPLists; ++i)
867 printTemplateParameters(D->getFriendTypeTemplateParameterList(i));
868 Out << "friend ";
869 Out << TSI->getType().getAsString(Policy);
870 }
872 dyn_cast(D->getFriendDecl())) {
873 Out << "friend ";
874 VisitFunctionDecl(FD);
875 }
877 dyn_cast(D->getFriendDecl())) {
878 Out << "friend ";
879 VisitFunctionTemplateDecl(FTD);
880 }
882 dyn_cast(D->getFriendDecl())) {
883 Out << "friend ";
884 VisitRedeclarableTemplateDecl(CTD);
885 }
886
887 if (D->isPackExpansion())
888 Out << "...";
889}
890
891void DeclPrinter::VisitFieldDecl(FieldDecl *D) {
892
894 Out << "mutable ";
896 Out << "__module_private__ ";
897
899 stream(Policy, D->getName(), Indentation);
900
901 if (D->isBitField()) {
902 Out << " : ";
903 D->getBitWidth()->printPretty(Out, nullptr, Policy, Indentation, "\n",
904 &Context);
905 }
906
907 Expr *Init = D->getInClassInitializer();
910 Out << " ";
911 else
912 Out << " = ";
913 Init->printPretty(Out, nullptr, Policy, Indentation, "\n", &Context);
914 }
915 prettyPrintAttributes(D);
916}
917
918void DeclPrinter::VisitLabelDecl(LabelDecl *D) {
919 Out << *D << ":";
920}
921
922void DeclPrinter::VisitVarDecl(VarDecl *D) {
923 prettyPrintPragmas(D);
924
925 prettyPrintAttributes(D, AttrPosAsWritten::Left);
926
927 if (const auto *Param = dyn_cast(D);
928 Param && Param->isExplicitObjectParameter())
929 Out << "this ";
930
932 ? D->getTypeSourceInfo()->getType()
934
939
940 switch (D->getTSCSpec()) {
942 break;
944 Out << "__thread ";
945 break;
947 Out << "_Thread_local ";
948 break;
950 Out << "thread_local ";
951 break;
952 }
953
955 Out << "__module_private__ ";
956
957 if (D->isConstexpr()) {
958 Out << "constexpr ";
959 T.removeLocalConst();
960 }
961 }
962
966
968 D->getIdentifier())
969 ? D->getIdentifier()->deuglifiedName()
970 : D->getName());
971
972 prettyPrintAttributes(D, AttrPosAsWritten::Right);
973
976 bool ImplicitInit = false;
977 if (D->isCXXForRangeDecl()) {
978
979 ImplicitInit = true;
981 dyn_cast(Init->IgnoreImplicit())) {
983 !Construct->isListInitialization()) {
984 ImplicitInit = Construct->getNumArgs() == 0 ||
985 Construct->getArg(0)->isDefaultArgument();
986 }
987 }
988 if (!ImplicitInit) {
990 Out << "(";
992 Out << " = ";
993 }
995 SubPolicy.SuppressSpecifiers = false;
996 SubPolicy.IncludeTagDefinition = false;
997 Init->printPretty(Out, nullptr, SubPolicy, Indentation, "\n", &Context);
999 Out << ")";
1000 }
1001 }
1002}
1003
1004void DeclPrinter::VisitParmVarDecl(ParmVarDecl *D) {
1005 VisitVarDecl(D);
1006}
1007
1009 Out << "__asm (";
1010 D->getAsmString()->printPretty(Out, nullptr, Policy, Indentation, "\n",
1011 &Context);
1012 Out << ")";
1013}
1014
1016 assert(D->getStmt());
1017 D->getStmt()->printPretty(Out, nullptr, Policy, Indentation, "\n", &Context);
1018}
1019
1020void DeclPrinter::VisitImportDecl(ImportDecl *D) {
1021 Out << "@import " << D->getImportedModule()->getFullModuleName()
1022 << ";\n";
1023}
1024
1026 Out << "static_assert(";
1027 D->getAssertExpr()->printPretty(Out, nullptr, Policy, Indentation, "\n",
1028 &Context);
1029 if (Expr *E = D->getMessage()) {
1030 Out << ", ";
1031 E->printPretty(Out, nullptr, Policy, Indentation, "\n", &Context);
1032 }
1033 Out << ")";
1034}
1035
1036
1037
1038
1039void DeclPrinter::VisitNamespaceDecl(NamespaceDecl *D) {
1040 if (D->isInline())
1041 Out << "inline ";
1042
1043 Out << "namespace ";
1044 if (D->getDeclName())
1045 Out << D->getDeclName() << ' ';
1046 Out << "{\n";
1047
1048 VisitDeclContext(D);
1049 Indent() << "}";
1050}
1051
1053 Out << "using namespace ";
1054 if (D->getQualifier())
1055 D->getQualifier()->print(Out, Policy);
1056 Out << *D->getNominatedNamespaceAsWritten();
1057}
1058
1060 Out << "namespace " << *D << " = ";
1061 if (D->getQualifier())
1062 D->getQualifier()->print(Out, Policy);
1063 Out << *D->getAliasedNamespace();
1064}
1065
1066void DeclPrinter::VisitEmptyDecl(EmptyDecl *D) {
1067 prettyPrintAttributes(D);
1068}
1069
1070void DeclPrinter::VisitCXXRecordDecl(CXXRecordDecl *D) {
1071
1073 Out << "__module_private__ ";
1074
1075 Out << D->getKindName() << ' ';
1076
1077
1078
1079 if (prettyPrintAttributes(D, AttrPosAsWritten::Left))
1080 Out << ' ';
1081
1082 if (D->getIdentifier()) {
1083 if (auto *NNS = D->getQualifier())
1084 NNS->print(Out, Policy);
1085 Out << *D;
1086
1087 if (auto *S = dyn_cast(D)) {
1089 S->getSpecializedTemplate()->getTemplateParameters();
1091 S->getTemplateArgsAsWritten();
1093 printTemplateArguments(TArgAsWritten->arguments(), TParams);
1094 else
1095 printTemplateArguments(S->getTemplateArgs().asArray(), TParams);
1096 }
1097 }
1098
1099 prettyPrintAttributes(D, AttrPosAsWritten::Right);
1100
1101 if (D->isCompleteDefinition()) {
1102 Out << ' ';
1103
1104 if (D->getNumBases()) {
1105 Out << ": ";
1107 BaseEnd = D->bases_end(); Base != BaseEnd; ++Base) {
1108 if (Base != D->bases_begin())
1109 Out << ", ";
1110
1111 if (Base->isVirtual())
1112 Out << "virtual ";
1113
1116 Print(AS);
1117 Out << " ";
1118 }
1119 Out << Base->getType().getAsString(Policy);
1120
1121 if (Base->isPackExpansion())
1122 Out << "...";
1123 }
1124 Out << ' ';
1125 }
1126
1127
1128
1130 Out << "{}";
1131 } else {
1132 Out << "{\n";
1133 VisitDeclContext(D);
1134 Indent() << "}";
1135 }
1136 }
1137}
1138
1140 const char *l;
1142 l = "C";
1143 else {
1145 "unknown language in linkage specification");
1146 l = "C++";
1147 }
1148
1149 Out << "extern \"" << l << "\" ";
1150 if (D->hasBraces()) {
1151 Out << "{\n";
1152 VisitDeclContext(D);
1153 Indent() << "}";
1154 } else
1155 Visit(*D->decls_begin());
1156}
1157
1159 bool OmitTemplateKW) {
1160 assert(Params);
1161
1162
1164 return;
1165
1166 if (!OmitTemplateKW)
1167 Out << "template ";
1168 Out << '<';
1169
1170 bool NeedComma = false;
1171 for (const Decl *Param : *Params) {
1172 if (Param->isImplicit())
1173 continue;
1174
1175 if (NeedComma)
1176 Out << ", ";
1177 else
1178 NeedComma = true;
1179
1180 if (const auto *TTP = dyn_cast(Param)) {
1181 VisitTemplateTypeParmDecl(TTP);
1182 } else if (auto NTTP = dyn_cast(Param)) {
1183 VisitNonTypeTemplateParmDecl(NTTP);
1184 } else if (auto TTPD = dyn_cast(Param)) {
1185 VisitTemplateDecl(TTPD);
1186
1187 }
1188 }
1189
1190 Out << '>';
1191
1192 if (const Expr *RequiresClause = Params->getRequiresClause()) {
1193 Out << " requires ";
1194 RequiresClause->printPretty(Out, nullptr, Policy, Indentation, "\n",
1195 &Context);
1196 }
1197
1198 if (!OmitTemplateKW)
1199 Out << ' ';
1200}
1201
1204 Out << "<";
1205 for (size_t I = 0, E = Args.size(); I < E; ++I) {
1206 if (I)
1207 Out << ", ";
1208 if (!Params)
1209 Args[I].print(Policy, Out, true);
1210 else
1211 Args[I].print(Policy, Out,
1213 Policy, Params, I));
1214 }
1215 Out << ">";
1216}
1217
1220 Out << "<";
1221 for (size_t I = 0, E = Args.size(); I < E; ++I) {
1222 if (I)
1223 Out << ", ";
1224 if (!Params)
1225 Args[I].getArgument().print(Policy, Out, true);
1226 else
1227 Args[I].getArgument().print(
1228 Policy, Out,
1230 I));
1231 }
1232 Out << ">";
1233}
1234
1235void DeclPrinter::VisitTemplateDecl(const TemplateDecl *D) {
1236 printTemplateParameters(D->getTemplateParameters());
1237
1239 dyn_cast(D)) {
1240 if (TTP->wasDeclaredWithTypename())
1241 Out << "typename";
1242 else
1243 Out << "class";
1244
1245 if (TTP->isParameterPack())
1246 Out << " ...";
1247 else if (TTP->getDeclName())
1248 Out << ' ';
1249
1250 if (TTP->getDeclName()) {
1252 Out << TTP->getIdentifier()->deuglifiedName();
1253 else
1254 Out << TTP->getDeclName();
1255 }
1256 } else if (auto *TD = D->getTemplatedDecl())
1257 Visit(TD);
1258 else if (const auto *Concept = dyn_cast(D)) {
1259 Out << "concept " << Concept->getName() << " = " ;
1260 Concept->getConstraintExpr()->printPretty(Out, nullptr, Policy, Indentation,
1261 "\n", &Context);
1262 }
1263}
1264
1266 prettyPrintPragmas(D->getTemplatedDecl());
1267
1268 if (const FunctionDecl *FD = D->getTemplatedDecl()) {
1270 I < NumTemplateParams; ++I)
1272 }
1273 VisitRedeclarableTemplateDecl(D);
1274
1275
1276 if (D->getTemplatedDecl()->hasAttr())
1277 Out << "#pragma omp end declare target\n";
1278
1279
1280
1281 if (PrintInstantiation &&
1282 !isa(D->getTemplatedDecl())) {
1285 if (PrevDecl->isDefined(Def) && Def != PrevDecl)
1286 return;
1287 for (auto *I : D->specializations())
1290 Out << ";\n";
1291 Indent();
1292 prettyPrintPragmas(I);
1293 Visit(I);
1294 }
1295 }
1296}
1297
1299 VisitRedeclarableTemplateDecl(D);
1300
1301 if (PrintInstantiation) {
1302 for (auto *I : D->specializations())
1304 if (D->isThisDeclarationADefinition())
1305 Out << ";";
1306 Out << "\n";
1307 Indent();
1308 Visit(I);
1309 }
1310 }
1311}
1312
1313void DeclPrinter::VisitClassTemplateSpecializationDecl(
1315 Out << "template<> ";
1316 VisitCXXRecordDecl(D);
1317}
1318
1319void DeclPrinter::VisitClassTemplatePartialSpecializationDecl(
1321 printTemplateParameters(D->getTemplateParameters());
1322 VisitCXXRecordDecl(D);
1323}
1324
1325
1326
1327
1328
1329void DeclPrinter::PrintObjCMethodType(ASTContext &Ctx,
1332 Out << '(';
1334 Out << "in ";
1336 Out << "inout ";
1338 Out << "out ";
1340 Out << "bycopy ";
1342 Out << "byref ";
1344 Out << "oneway ";
1348 }
1349
1351 Out << ')';
1352}
1353
1354void DeclPrinter::PrintObjCTypeParams(ObjCTypeParamList *Params) {
1355 Out << "<";
1356 unsigned First = true;
1357 for (auto *Param : *Params) {
1360 } else {
1361 Out << ", ";
1362 }
1363
1364 switch (Param->getVariance()) {
1366 break;
1367
1369 Out << "__covariant ";
1370 break;
1371
1373 Out << "__contravariant ";
1374 break;
1375 }
1376
1377 Out << Param->getDeclName();
1378
1379 if (Param->hasExplicitBound()) {
1380 Out << " : " << Param->getUnderlyingType().getAsString(Policy);
1381 }
1382 }
1383 Out << ">";
1384}
1385
1386void DeclPrinter::VisitObjCMethodDecl(ObjCMethodDecl *OMD) {
1388 Out << "- ";
1389 else
1390 Out << "+ ";
1394 }
1395
1397 std:🧵:size_type pos, lastPos = 0;
1398 for (const auto *PI : OMD->parameters()) {
1399
1400 pos = name.find_first_of(':', lastPos);
1401 if (lastPos != 0)
1402 Out << " ";
1403 Out << name.substr(lastPos, pos - lastPos) << ':';
1405 PI->getObjCDeclQualifier(),
1406 PI->getType());
1407 Out << *PI;
1408 lastPos = pos + 1;
1409 }
1410
1412 Out << name;
1413
1415 Out << ", ...";
1416
1417 prettyPrintAttributes(OMD);
1418
1420 Out << ' ';
1421 OMD->getBody()->printPretty(Out, nullptr, Policy, Indentation, "\n",
1422 &Context);
1423 }
1425 Out << ';';
1426}
1427
1431
1432 bool eolnOut = false;
1433 if (SID)
1434 Out << "@implementation " << I << " : " << *SID;
1435 else
1436 Out << "@implementation " << I;
1437
1439 Out << "{\n";
1440 eolnOut = true;
1442 for (const auto *I : OID->ivars()) {
1443 Indent() << I->getASTContext().getUnqualifiedObjCPointerType(I->getType()).
1444 getAsString(Policy) << ' ' << *I << ";\n";
1445 }
1447 Out << "}\n";
1448 }
1450 Out << "\n";
1451 eolnOut = true;
1452 }
1453 VisitDeclContext(OID, false);
1454 if (!eolnOut)
1455 Out << "\n";
1456 Out << "@end";
1457}
1458
1459void DeclPrinter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *OID) {
1462
1464 Out << "@class " << I;
1465
1467 PrintObjCTypeParams(TypeParams);
1468 }
1469
1470 Out << ";";
1471 return;
1472 }
1473 bool eolnOut = false;
1475 prettyPrintAttributes(OID);
1476 Out << "\n";
1477 }
1478
1479 Out << "@interface " << I;
1480
1482 PrintObjCTypeParams(TypeParams);
1483 }
1484
1485 if (SID)
1487
1488
1490 if (!Protocols.empty()) {
1492 E = Protocols.end(); I != E; ++I)
1493 Out << (I == Protocols.begin() ? '<' : ',') << **I;
1494 Out << "> ";
1495 }
1496
1498 Out << "{\n";
1499 eolnOut = true;
1501 for (const auto *I : OID->ivars()) {
1502 Indent() << I->getASTContext()
1503 .getUnqualifiedObjCPointerType(I->getType())
1504 .getAsString(Policy) << ' ' << *I << ";\n";
1505 }
1507 Out << "}\n";
1508 }
1510 Out << "\n";
1511 eolnOut = true;
1512 }
1513
1514 VisitDeclContext(OID, false);
1515 if (!eolnOut)
1516 Out << "\n";
1517 Out << "@end";
1518
1519}
1520
1521void DeclPrinter::VisitObjCProtocolDecl(ObjCProtocolDecl *PID) {
1523 Out << "@protocol " << *PID << ";\n";
1524 return;
1525 }
1526
1528 if (!Protocols.empty()) {
1529 Out << "@protocol " << *PID;
1531 E = Protocols.end(); I != E; ++I)
1532 Out << (I == Protocols.begin() ? '<' : ',') << **I;
1533 Out << ">\n";
1534 } else
1535 Out << "@protocol " << *PID << '\n';
1536 VisitDeclContext(PID, false);
1537 Out << "@end";
1538}
1539
1541 Out << "@implementation ";
1543 Out << *CID;
1544 else
1545 Out << "<>";
1546 Out << '(' << *PID << ")\n";
1547
1548 VisitDeclContext(PID, false);
1549 Out << "@end";
1550
1551}
1552
1553void DeclPrinter::VisitObjCCategoryDecl(ObjCCategoryDecl *PID) {
1554 Out << "@interface ";
1556 Out << *CID;
1557 else
1558 Out << "<>";
1560 PrintObjCTypeParams(TypeParams);
1561 }
1562 Out << "(" << *PID << ")\n";
1563 if (PID->ivar_size() > 0) {
1564 Out << "{\n";
1566 for (const auto *I : PID->ivars())
1567 Indent() << I->getASTContext().getUnqualifiedObjCPointerType(I->getType()).
1568 getAsString(Policy) << ' ' << *I << ";\n";
1570 Out << "}\n";
1571 }
1572
1573 VisitDeclContext(PID, false);
1574 Out << "@end";
1575
1576
1577}
1578
1580 Out << "@compatibility_alias " << *AID
1582}
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593void DeclPrinter::VisitObjCPropertyDecl(ObjCPropertyDecl *PDecl) {
1595 Out << "@required\n";
1597 Out << "@optional\n";
1598
1600
1601 Out << "@property";
1603 bool first = true;
1604 Out << "(";
1606 Out << (first ? "" : ", ") << "class";
1607 first = false;
1608 }
1609
1611 Out << (first ? "" : ", ") << "direct";
1612 first = false;
1613 }
1614
1617 Out << (first ? "" : ", ") << "nonatomic";
1618 first = false;
1619 }
1621 Out << (first ? "" : ", ") << "atomic";
1622 first = false;
1623 }
1624
1626 Out << (first ? "" : ", ") << "assign";
1627 first = false;
1628 }
1630 Out << (first ? "" : ", ") << "retain";
1631 first = false;
1632 }
1633
1635 Out << (first ? "" : ", ") << "strong";
1636 first = false;
1637 }
1639 Out << (first ? "" : ", ") << "copy";
1640 first = false;
1641 }
1643 Out << (first ? "" : ", ") << "weak";
1644 first = false;
1645 }
1648 Out << (first ? "" : ", ") << "unsafe_unretained";
1649 first = false;
1650 }
1651
1654 Out << (first ? "" : ", ") << "readwrite";
1655 first = false;
1656 }
1658 Out << (first ? "" : ", ") << "readonly";
1659 first = false;
1660 }
1661
1663 Out << (first ? "" : ", ") << "getter = ";
1665 first = false;
1666 }
1668 Out << (first ? "" : ", ") << "setter = ";
1670 first = false;
1671 }
1672
1679 Out << (first ? "" : ", ") << "null_resettable";
1680 } else {
1681 Out << (first ? "" : ", ")
1683 }
1684 first = false;
1685 }
1686 }
1687
1688 (void) first;
1689 Out << ")";
1690 }
1693 Out << ' ' << TypeStr;
1694 if (!StringRef(TypeStr).ends_with("*"))
1695 Out << ' ';
1696 Out << *PDecl;
1698 Out << ';';
1699}
1700
1703 Out << "@synthesize ";
1704 else
1705 Out << "@dynamic ";
1709}
1710
1711void DeclPrinter::VisitUsingDecl(UsingDecl *D) {
1712 if (->isAccessDeclaration())
1713 Out << "using ";
1714 if (D->hasTypename())
1715 Out << "typename ";
1716 D->getQualifier()->print(Out, Policy);
1717
1718
1719
1720 for (const auto *Shadow : D->shadows()) {
1721 if (const auto *ConstructorShadow =
1722 dyn_cast(Shadow)) {
1723 assert(Shadow->getDeclContext() == ConstructorShadow->getDeclContext());
1724 Out << *ConstructorShadow->getNominatedBaseClass();
1725 return;
1726 }
1727 }
1728 Out << *D;
1729}
1730
1731void DeclPrinter::VisitUsingEnumDecl(UsingEnumDecl *D) {
1732 Out << "using enum " << D->getEnumDecl();
1733}
1734
1735void
1737 Out << "using typename ";
1738 D->getQualifier()->print(Out, Policy);
1739 Out << D->getDeclName();
1740}
1741
1743 if (->isAccessDeclaration())
1744 Out << "using ";
1745 D->getQualifier()->print(Out, Policy);
1746 Out << D->getDeclName();
1747}
1748
1750
1751}
1752
1754 Out << "#pragma omp threadprivate";
1755 if (->varlist_empty()) {
1758 I != E; ++I) {
1759 Out << (I == D->varlist_begin() ? '(' : ',');
1760 NamedDecl *ND = cast(*I)->getDecl();
1762 }
1763 Out << ")";
1764 }
1765}
1766
1767void DeclPrinter::VisitHLSLBufferDecl(HLSLBufferDecl *D) {
1768 if (D->isCBuffer())
1769 Out << "cbuffer ";
1770 else
1771 Out << "tbuffer ";
1772
1773 Out << *D;
1774
1775 prettyPrintAttributes(D);
1776
1777 Out << " {\n";
1778 VisitDeclContext(D);
1779 Indent() << "}";
1780}
1781
1783 Out << "#pragma omp allocate";
1784 if (->varlist_empty()) {
1787 I != E; ++I) {
1788 Out << (I == D->varlist_begin() ? '(' : ',');
1789 NamedDecl *ND = cast(*I)->getDecl();
1791 }
1792 Out << ")";
1793 }
1794 if (->clauselist_empty()) {
1797 Out << " ";
1798 Printer.Visit(C);
1799 }
1800 }
1801}
1802
1804 Out << "#pragma omp requires ";
1805 if (->clauselist_empty()) {
1807 for (auto I = D->clauselist_begin(), E = D->clauselist_end(); I != E; ++I)
1808 Printer.Visit(*I);
1809 }
1810}
1811
1814 Out << "#pragma omp declare reduction (";
1816 const char *OpName =
1818 assert(OpName && "not an overloaded operator");
1819 Out << OpName;
1820 } else {
1821 assert(D->getDeclName().isIdentifier());
1822 D->printName(Out, Policy);
1823 }
1824 Out << " : ";
1825 D->getType().print(Out, Policy);
1826 Out << " : ";
1827 D->getCombiner()->printPretty(Out, nullptr, Policy, 0, "\n", &Context);
1828 Out << ")";
1829 if (auto *Init = D->getInitializer()) {
1830 Out << " initializer(";
1831 switch (D->getInitializerKind()) {
1833 Out << "omp_priv(";
1834 break;
1836 Out << "omp_priv = ";
1837 break;
1839 break;
1840 }
1841 Init->printPretty(Out, nullptr, Policy, 0, "\n", &Context);
1843 Out << ")";
1844 Out << ")";
1845 }
1846 }
1847}
1848
1851 Out << "#pragma omp declare mapper (";
1852 D->printName(Out, Policy);
1853 Out << " : ";
1854 D->getType().print(Out, Policy);
1855 Out << " ";
1856 Out << D->getVarName();
1857 Out << ")";
1858 if (->clauselist_empty()) {
1860 for (auto *C : D->clauselists()) {
1861 Out << " ";
1862 Printer.Visit(C);
1863 }
1864 }
1865 }
1866}
1867
1869 D->getInit()->printPretty(Out, nullptr, Policy, Indentation, "\n", &Context);
1870}
1871
1872void DeclPrinter::VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *TTP) {
1874 TC->print(Out, Policy);
1876 Out << "typename";
1877 else
1878 Out << "class";
1879
1881 Out << " ...";
1883 Out << ' ';
1884
1888 else
1890 }
1891
1893 Out << " = ";
1895 false);
1896 }
1897}
1898
1899void DeclPrinter::VisitNonTypeTemplateParmDecl(
1901 StringRef Name;
1903 Name =
1906
1908 Out << " = ";
1910 false);
1911 }
1912}
Defines the clang::ASTContext interface.
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
static DeclPrinter::AttrPosAsWritten getPosAsWritten(const Attr *A, const Decl *D)
static QualType getDeclType(Decl *D)
static QualType GetBaseType(QualType T)
static void MaybePrintTagKeywordIfSupressingScopes(PrintingPolicy &Policy, QualType T, llvm::raw_ostream &Out)
static void printExplicitSpecifier(ExplicitSpecifier ES, llvm::raw_ostream &Out, PrintingPolicy &Policy, unsigned Indentation, const ASTContext &Context)
Defines the C++ template declaration subclasses.
Defines the clang::Expr interface and subclasses for C++ expressions.
Defines the clang::Module class, which describes a module in the source code.
Defines the SourceManager interface.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
const LangOptions & getLangOpts() const
const clang::PrintingPolicy & getPrintingPolicy() const
QualType getUnqualifiedObjCPointerType(QualType type) const
getUnqualifiedObjCPointerType - Returns version of Objective-C pointer type with lifetime qualifier r...
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Attr - This represents one attribute.
SourceLocation getLoc() const
static std::optional< NullabilityKind > stripOuterNullability(QualType &T)
Strip off the top-level nullability annotation on the given type, if it's there.
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
Represents a base class of a C++ class.
Represents a call to a C++ constructor.
Represents a C++ constructor within a class.
Represents a C++ conversion function within a class.
Represents a C++ deduction guide declaration.
TemplateDecl * getDeducedTemplate() const
Get the template for which this guide performs deduction.
Represents a C++ struct/union/class.
Declaration of a class template.
Represents a class template specialization, which refers to a class template with a given set of temp...
decl_iterator - Iterates through the declarations stored within this context.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
bool isTranslationUnit() const
void dumpDeclContext() const
decl_iterator decls_end() const
decl_iterator decls_begin() const
A simple visitor class that helps create declaration visitors.
Decl - This represents one declaration (or definition), e.g.
bool isModulePrivate() const
Whether this declaration was marked as being private to the module in which it was defined.
ASTContext & getASTContext() const LLVM_READONLY
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
virtual Stmt * getBody() const
getBody - If this Decl represents a declaration for a body of code, such as a function or method defi...
ObjCDeclQualifier
ObjCDeclQualifier - 'Qualifiers' written next to the return and parameter types in method declaration...
@ OBJC_TQ_CSNullability
The nullability qualifier is set when the nullability of the result or parameter was expressed via a ...
bool isInvalidDecl() const
SourceLocation getLocation() const
static void printGroup(Decl **Begin, unsigned NumDecls, raw_ostream &Out, const PrintingPolicy &Policy, unsigned Indentation=0)
AccessSpecifier getAccess() const
void print(raw_ostream &Out, unsigned Indentation=0, bool PrintInstantiation=false) const
std::string getAsString() const
Retrieve the human-readable string for this name.
TemplateParameterList * getTemplateParameterList(unsigned index) const
unsigned getNumTemplateParameterLists() const
Represents an empty-declaration.
An instance of this object exists for each enum constant that is defined.
Store information needed for an explicit specifier.
const Expr * getExpr() const
static ExplicitSpecifier getFromDecl(FunctionDecl *Function)
bool isSpecified() const
Determine if the declaration had an explicit specifier of any kind.
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
This represents one expression.
Represents a member of a struct/union/class.
FriendDecl - Represents the declaration of a friend entity, which can be a function,...
Represents a function declaration or definition.
bool isThisDeclarationADefinition() const
Returns whether this specific declaration of the function is also a definition that does not contain ...
bool isDefined(const FunctionDecl *&Definition, bool CheckForPendingFriendDefinition=false) const
Returns true if the function has a definition that does not need to be instantiated.
Represents a prototype with parameter type info, e.g.
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
bool hasTrailingReturn() const
Whether this function prototype has a trailing return type.
QualType getExceptionType(unsigned i) const
Return the ith exception type, where 0 <= i < getNumExceptions().
unsigned getNumExceptions() const
Return the number of types in the exception specification.
bool hasDynamicExceptionSpec() const
Return whether this function has a dynamic (throw) exception spec.
bool isVariadic() const
Whether this function prototype is variadic.
Expr * getNoexceptExpr() const
Return the expression inside noexcept(expression), or a null pointer if there is none (because the ex...
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this function type.
Declaration of a template function.
FunctionType - C99 6.7.5.3 - Function Declarators.
HLSLBufferDecl - Represent a cbuffer or tbuffer declaration.
One of these records is kept for each identifier that is lexed.
StringRef deuglifiedName() const
If the identifier is an "uglified" reserved name, return a cleaned form.
Describes a module import declaration, which makes the contents of the named module visible in the cu...
Represents the declaration of a label.
Represents a linkage specification.
This represents a decl that may have a name.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
std::string getNameAsString() const
Get a human-readable name for the declaration, even if it is one of the special kinds of names (C++ c...
void printQualifiedName(raw_ostream &OS) const
Returns a human-readable qualified name for this declaration, like A::B::i, for i being member of nam...
Represents a C++ namespace alias.
Represent a C++ namespace.
Represents a C++ nested name specifier, such as "\::std::vector::".
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
const TemplateArgumentLoc & getDefaultArgument() const
Retrieve the default argument, if any.
bool isParameterPack() const
Whether this parameter is a non-type template parameter pack.
This represents '#pragma omp allocate ...' directive.
MutableArrayRef< Expr * >::iterator varlist_iterator
Pseudo declaration for capturing expressions.
This is a basic class for representing single OpenMP clause.
This represents '#pragma omp declare mapper ...' directive.
This represents '#pragma omp declare reduction ...' directive.
This represents '#pragma omp requires...' directive.
This represents '#pragma omp threadprivate ...' directive.
MutableArrayRef< Expr * >::iterator varlist_iterator
ObjCCategoryDecl - Represents a category declaration.
ObjCInterfaceDecl * getClassInterface()
ObjCTypeParamList * getTypeParamList() const
Retrieve the type parameter list associated with this category or extension.
ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration.
ObjCCompatibleAliasDecl - Represents alias of a class.
const ObjCInterfaceDecl * getClassInterface() const
const ObjCInterfaceDecl * getClassInterface() const
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
std::string getNameAsString() const
Get the name of the class associated with this interface.
unsigned ivar_size() const
const ObjCInterfaceDecl * getSuperClass() const
Represents an ObjC class declaration.
unsigned ivar_size() const
ObjCTypeParamList * getTypeParamListAsWritten() const
Retrieve the type parameters written on this particular declaration of the class.
bool isThisDeclarationADefinition() const
Determine whether this particular declaration of this class is actually also a definition.
const ObjCProtocolList & getReferencedProtocols() const
const ObjCObjectType * getSuperClassType() const
Retrieve the superclass type.
ObjCInterfaceDecl * getSuperClass() const
ObjCList - This is a simple template class used to hold various lists of decls etc,...
ObjCMethodDecl - Represents an instance or class method declaration.
ObjCDeclQualifier getObjCDeclQualifier() const
ArrayRef< ParmVarDecl * > parameters() const
param_const_iterator param_end() const
param_const_iterator param_begin() const
Stmt * getBody() const override
Retrieve the body of this method, if it has one.
Selector getSelector() const
bool isInstanceMethod() const
QualType getReturnType() const
Represents a pointer to an Objective C object.
Represents one property declaration in an Objective-C interface.
Selector getSetterName() const
Selector getGetterName() const
ObjCPropertyAttribute::Kind getPropertyAttributes() const
PropertyControl getPropertyImplementation() const
ObjCPropertyImplDecl - Represents implementation declaration of a property in a class or category imp...
ObjCIvarDecl * getPropertyIvarDecl() const
Kind getPropertyImplementation() const
ObjCPropertyDecl * getPropertyDecl() const
Represents an Objective-C protocol declaration.
bool isThisDeclarationADefinition() const
Determine whether this particular declaration is also the definition.
const ObjCProtocolList & getReferencedProtocols() const
Stores a list of Objective-C type parameters for a parameterized class or a category/extension thereo...
Represents a pack expansion of types.
Sugar for parentheses used when specifying types.
Represents a parameter to a function.
PointerType - C99 6.7.5.1 - Pointer Declarators.
A (possibly-)qualified type.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
void print(raw_ostream &OS, const PrintingPolicy &Policy, const Twine &PlaceHolder=Twine(), unsigned Indentation=0) const
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
Represents a struct/union/class.
Base for LValueReferenceType and RValueReferenceType.
std::string getAsString() const
Derive the full selector name (e.g.
void print(llvm::raw_ostream &OS) const
Prints the full selector name (e.g. "foo:bar:").
Encodes a location in the source.
Represents a C++11 static_assert declaration.
void printPretty(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\n", const ASTContext *Context=nullptr) const
void printPrettyControlled(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\n", const ASTContext *Context=nullptr) const
StringLiteral - This represents a string literal expression, e.g.
Represents the declaration of a struct/union/class/enum.
A template argument list.
const TemplateArgument & getArgument() const
void print(const PrintingPolicy &Policy, raw_ostream &Out, bool IncludeType) const
Print this template argument to the given output stream.
The base class of all kinds of template declarations (e.g., class, function, etc.).
Stores a list of template parameters for a TemplateDecl and its derived classes.
NamedDecl * getParam(unsigned Idx)
void print(raw_ostream &Out, const ASTContext &Context, bool OmitTemplateKW=false) const
static bool shouldIncludeTypeForArgument(const PrintingPolicy &Policy, const TemplateParameterList *TPL, unsigned Idx)
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
Declaration of a template type parameter.
bool wasDeclaredWithTypename() const
Whether this template type parameter was declared with the 'typename' keyword.
const TemplateArgumentLoc & getDefaultArgument() const
Retrieve the default argument, if any.
const TypeConstraint * getTypeConstraint() const
Returns the type constraint associated with this template parameter (if any).
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
bool isParameterPack() const
Returns whether this is a parameter pack.
A declaration that models statements at global scope.
The top declaration context.
Represents the declaration of a typedef-name via a C++11 alias-declaration.
Models the abbreviated syntax to constrain a template type parameter: template <convertible_to<string...
A container of type source information.
bool isStructureType() const
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isSpecifierType() const
Returns true if this type can be represented by some set of type specifiers.
const T * getAs() const
Member-template getAs'.
Represents the declaration of a typedef-name via the 'typedef' type specifier.
Base class for declarations which introduce a typedef-name.
Represents a dependent using declaration which was marked with typename.
Represents a dependent using declaration which was not marked with typename.
Represents a C++ using-declaration.
Represents C++ using-directive.
Represents a C++ using-enum-declaration.
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Represents a variable declaration or definition.
static const char * getStorageClassSpecifierString(StorageClass SC)
Return the string used to specify the storage class SC.
@ CInit
C-style initialization with assignment.
@ CallInit
Call-style initialization (C++98)
Represents a GCC generic vector type.
@ kind_nullability
Indicates that the nullability of the type was spelled with a property attribute rather than a type q...
RangeSelector name(std::string ID)
Given a node with a "name", (like NamedDecl, DeclRefExpr, CxxCtorInitializer, and TypeLoc) selects th...
The JSON file list parser is used to communicate input to InstallAPI.
llvm::StringRef getAccessSpelling(AccessSpecifier AS)
@ Unspecified
Whether values of this type can be null is (explicitly) unspecified.
@ ICIS_ListInit
Direct list-initialization.
@ RQ_None
No ref-qualifier was provided.
@ RQ_LValue
An lvalue ref-qualifier was provided (&).
@ RQ_RValue
An rvalue ref-qualifier was provided (&&).
StorageClass
Storage classes.
@ TSCS_thread_local
C++11 thread_local.
@ TSCS__Thread_local
C11 _Thread_local.
@ TSCS___thread
GNU __thread.
llvm::StringRef getNullabilitySpelling(NullabilityKind kind, bool isContextSensitive=false)
Retrieve the spelling of the given nullability kind.
bool isComputedNoexcept(ExceptionSpecificationType ESpecType)
bool isNoexceptExceptionSpec(ExceptionSpecificationType ESpecType)
const FunctionProtoType * T
llvm::StringRef getAsString(SyncScope S)
@ TSK_ImplicitInstantiation
This template specialization was implicitly instantiated from a template.
@ Invariant
The parameter is invariant: must match exactly.
@ Contravariant
The parameter is contravariant, e.g., X is a subtype of X when the type parameter is covariant and...
@ Covariant
The parameter is covariant, e.g., X is a subtype of X when the type parameter is covariant and T i...
const char * getOperatorSpelling(OverloadedOperatorKind Operator)
Retrieve the spelling of the given overloaded operator, without the preceding "operator" keyword.
@ EST_MSAny
Microsoft throw(...) extension.
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Represents an explicit template argument list in C++, e.g., the "" in "sort".
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
Describes how types, statements, expressions, and declarations should be printed.
unsigned SuppressUnwrittenScope
Suppress printing parts of scope specifiers that are never written, e.g., for anonymous namespaces.
unsigned FullyQualifiedName
When true, print the fully qualified name of function declarations.
unsigned PrintCanonicalTypes
Whether to print types as written or canonically.
unsigned PolishForDeclaration
When true, do certain refinement needed for producing proper declaration tag; such as,...
unsigned CleanUglifiedParameters
Whether to strip underscores when printing reserved parameter names.
unsigned SuppressSpecifiers
Whether we should suppress printing of the actual specifiers for the given type or declaration.
unsigned SuppressTagKeyword
Whether type printing should skip printing the tag keyword.
unsigned SuppressScope
Suppresses printing of scope specifiers.
unsigned Indentation
The number of spaces to use to indent each line.
unsigned SuppressInitializers
Suppress printing of variable initializers.
unsigned IncludeTagDefinition
When true, include the body of a tag definition.
unsigned TerseOutput
Provide a 'terse' output.