22 #include "llvm/ADT/SmallString.h"
23 #include "llvm/Support/raw_ostream.h"
25 using namespace clang;
41 if (
const ParenType *PT = dyn_cast<ParenType>(Ty)) {
47 dyn_cast<SubstTemplateTypeParmType>(Ty)) {
57 if (
const AdjustedType *AT = dyn_cast<AdjustedType>(Ty)) {
62 if (
const AutoType *AT = dyn_cast<AutoType>(Ty)) {
71 if (
const FunctionType *FT = dyn_cast<FunctionType>(Ty)) {
72 bool DesugarReturn =
false;
73 QualType SugarRT = FT->getReturnType();
80 bool DesugarArgument =
false;
86 if (
auto nullability =
95 if (DesugarReturn || DesugarArgument) {
106 dyn_cast<TemplateSpecializationType>(Ty)) {
107 if (!TST->isTypeAlias()) {
108 bool DesugarArgument =
false;
110 for (
unsigned I = 0, N = TST->getNumArgs();
I != N; ++
I) {
118 if (DesugarArgument) {
121 TST->getTemplateName(), Args.data(), Args.size(), QT);
141 bool IsSugar =
false;
143 #define ABSTRACT_TYPE(Class, Base)
144 #define TYPE(Class, Base) \
145 case Type::Class: { \
146 const Class##Type *CTy = cast<Class##Type>(Ty); \
147 if (CTy->isSugared()) { \
149 Underlying = CTy->desugar(); \
153 #include "clang/AST/TypeNodes.def"
162 if (isa<VectorType>(Underlying))
167 if (
const TypedefType *QTT = dyn_cast<TypedefType>(QT))
168 if (UTT->getDecl()->getTypedefNameForAnonDecl() == QTT->getDecl())
191 if (Ty->getBaseType().getTypePtr() != Ty && !ShouldAKA) {
194 llvm::makeArrayRef(Ty->qual_begin(),
195 Ty->getNumProtocols()),
196 Ty->isKindOfTypeAsWritten());
200 return QC.
apply(Context, QT);
232 bool ForceAKA =
false;
237 for (
unsigned I = 0,
E = QualTypeVals.size();
I !=
E; ++
I) {
245 if (CompareCanTy == CanTy)
248 bool ShouldAKA =
false;
250 std::string CompareDesugarStr =
252 if (CompareS != S && CompareDesugarStr != S)
255 std::string CompareCanS =
258 if (CompareCanS == CanS)
267 bool Repeated =
false;
268 for (
unsigned i = 0, e = PrevArgs.size(); i != e; ++i) {
271 void *Ptr = (
void*)PrevArgs[i].second;
283 bool ShouldAKA =
false;
285 if (ShouldAKA || ForceAKA) {
286 if (DesugaredTy == Ty) {
291 S =
"'" + S +
"' (aka '" + akaStr +
"')";
301 std::string DecoratedString;
302 llvm::raw_string_ostream OS(DecoratedString);
303 const char *Values = VTy->
getNumElements() > 1 ?
"values" :
"value";
304 OS <<
"'" << S <<
"' (vector of " << VTy->
getNumElements() <<
" '"
306 <<
"' " << Values <<
")";
317 bool PrintFromType,
bool ElideType,
318 bool ShowColors, raw_ostream &OS);
331 size_t OldEnd = Output.size();
332 llvm::raw_svector_ostream OS(Output);
333 bool NeedQuotes =
true;
336 default: llvm_unreachable(
"unknown ArgumentKind");
360 Modifier = StringRef();
361 Argument = StringRef();
365 assert(Modifier.empty() && Argument.empty() &&
366 "Invalid modifier for QualType argument");
374 if (Modifier ==
"objcclass" && Argument.empty())
376 else if (Modifier ==
"objcinstance" && Argument.empty())
379 assert(Modifier.empty() && Argument.empty() &&
380 "Invalid modifier for DeclarationName argument");
387 if (Modifier ==
"q" && Argument.empty())
390 assert(Modifier.empty() && Argument.empty() &&
391 "Invalid modifier for NamedDecl* argument");
406 assert(DC &&
"Should never have a null declaration context");
412 OS <<
"the global namespace";
414 OS <<
"the global scope";
416 OS <<
"block literal";
418 OS <<
"lambda expression";
422 PrevArgs, QualTypeVals);
424 assert(isa<NamedDecl>(DC) &&
"Expected a NamedDecl");
426 if (isa<NamespaceDecl>(ND))
428 else if (isa<ObjCMethodDecl>(ND))
430 else if (isa<FunctionDecl>(ND))
440 const Attr *At =
reinterpret_cast<Attr *
>(Val);
441 assert(At &&
"Received null Attr object!");
450 Output.insert(Output.begin()+OldEnd,
'\'');
451 Output.push_back(
'\'');
516 FromIntegerAndToDeclaration,
517 FromDeclarationAndToInteger
524 struct TemplateArgumentInfo {
528 bool IsValidInt =
false;
529 Expr *ArgExpr =
nullptr;
532 bool NeedAddressOf =
false;
533 bool IsNullPtr =
false;
534 bool IsDefault =
false;
544 unsigned NextNode = 0;
547 unsigned ChildNode = 0;
550 unsigned ParentNode = 0;
552 TemplateArgumentInfo FromArgInfo, ToArgInfo;
557 DiffNode(
unsigned ParentNode = 0) : ParentNode(ParentNode) {}
564 unsigned CurrentNode;
568 unsigned NextFreeNode;
575 CurrentNode(0), NextFreeNode(1) {
576 FlatTree.push_back(DiffNode());
582 bool FromDefault,
bool ToDefault) {
583 assert(FlatTree[CurrentNode].
Kind == Invalid &&
"Node is not empty.");
584 FlatTree[CurrentNode].Kind = Template;
585 FlatTree[CurrentNode].FromArgInfo.TD = FromTD;
586 FlatTree[CurrentNode].ToArgInfo.TD = ToTD;
587 FlatTree[CurrentNode].FromArgInfo.Qual = FromQual;
588 FlatTree[CurrentNode].ToArgInfo.Qual = ToQual;
589 SetDefault(FromDefault, ToDefault);
594 assert(FlatTree[CurrentNode].
Kind == Invalid &&
"Node is not empty.");
595 FlatTree[CurrentNode].Kind =
Type;
596 FlatTree[CurrentNode].FromArgInfo.ArgType = FromType;
597 FlatTree[CurrentNode].ToArgInfo.ArgType = ToType;
598 SetDefault(FromDefault, ToDefault);
601 void SetExpressionDiff(
Expr *FromExpr,
Expr *ToExpr,
bool FromDefault,
603 assert(FlatTree[CurrentNode].
Kind == Invalid &&
"Node is not empty.");
604 FlatTree[CurrentNode].Kind = Expression;
605 FlatTree[CurrentNode].FromArgInfo.ArgExpr = FromExpr;
606 FlatTree[CurrentNode].ToArgInfo.ArgExpr = ToExpr;
607 SetDefault(FromDefault, ToDefault);
611 bool FromDefault,
bool ToDefault) {
612 assert(FlatTree[CurrentNode].
Kind == Invalid &&
"Node is not empty.");
613 FlatTree[CurrentNode].Kind = TemplateTemplate;
614 FlatTree[CurrentNode].FromArgInfo.TD = FromTD;
615 FlatTree[CurrentNode].ToArgInfo.TD = ToTD;
616 SetDefault(FromDefault, ToDefault);
619 void SetIntegerDiff(llvm::APSInt FromInt, llvm::APSInt ToInt,
620 bool IsValidFromInt,
bool IsValidToInt,
622 Expr *FromExpr,
Expr *ToExpr,
bool FromDefault,
624 assert(FlatTree[CurrentNode].
Kind == Invalid &&
"Node is not empty.");
625 FlatTree[CurrentNode].Kind = Integer;
626 FlatTree[CurrentNode].FromArgInfo.Val = FromInt;
627 FlatTree[CurrentNode].ToArgInfo.Val = ToInt;
628 FlatTree[CurrentNode].FromArgInfo.IsValidInt = IsValidFromInt;
629 FlatTree[CurrentNode].ToArgInfo.IsValidInt = IsValidToInt;
630 FlatTree[CurrentNode].FromArgInfo.ArgType = FromIntType;
631 FlatTree[CurrentNode].ToArgInfo.ArgType = ToIntType;
632 FlatTree[CurrentNode].FromArgInfo.ArgExpr = FromExpr;
633 FlatTree[CurrentNode].ToArgInfo.ArgExpr = ToExpr;
634 SetDefault(FromDefault, ToDefault);
638 bool FromAddressOf,
bool ToAddressOf,
639 bool FromNullPtr,
bool ToNullPtr,
Expr *FromExpr,
640 Expr *ToExpr,
bool FromDefault,
bool ToDefault) {
641 assert(FlatTree[CurrentNode].
Kind == Invalid &&
"Node is not empty.");
642 FlatTree[CurrentNode].Kind = Declaration;
643 FlatTree[CurrentNode].FromArgInfo.VD = FromValueDecl;
644 FlatTree[CurrentNode].ToArgInfo.VD = ToValueDecl;
645 FlatTree[CurrentNode].FromArgInfo.NeedAddressOf = FromAddressOf;
646 FlatTree[CurrentNode].ToArgInfo.NeedAddressOf = ToAddressOf;
647 FlatTree[CurrentNode].FromArgInfo.IsNullPtr = FromNullPtr;
648 FlatTree[CurrentNode].ToArgInfo.IsNullPtr = ToNullPtr;
649 FlatTree[CurrentNode].FromArgInfo.ArgExpr = FromExpr;
650 FlatTree[CurrentNode].ToArgInfo.ArgExpr = ToExpr;
651 SetDefault(FromDefault, ToDefault);
654 void SetFromDeclarationAndToIntegerDiff(
655 ValueDecl *FromValueDecl,
bool FromAddressOf,
bool FromNullPtr,
656 Expr *FromExpr, llvm::APSInt ToInt,
bool IsValidToInt,
657 QualType ToIntType,
Expr *ToExpr,
bool FromDefault,
bool ToDefault) {
658 assert(FlatTree[CurrentNode].
Kind == Invalid &&
"Node is not empty.");
659 FlatTree[CurrentNode].Kind = FromDeclarationAndToInteger;
660 FlatTree[CurrentNode].FromArgInfo.VD = FromValueDecl;
661 FlatTree[CurrentNode].FromArgInfo.NeedAddressOf = FromAddressOf;
662 FlatTree[CurrentNode].FromArgInfo.IsNullPtr = FromNullPtr;
663 FlatTree[CurrentNode].FromArgInfo.ArgExpr = FromExpr;
664 FlatTree[CurrentNode].ToArgInfo.Val = ToInt;
665 FlatTree[CurrentNode].ToArgInfo.IsValidInt = IsValidToInt;
666 FlatTree[CurrentNode].ToArgInfo.ArgType = ToIntType;
667 FlatTree[CurrentNode].ToArgInfo.ArgExpr = ToExpr;
668 SetDefault(FromDefault, ToDefault);
671 void SetFromIntegerAndToDeclarationDiff(
672 llvm::APSInt FromInt,
bool IsValidFromInt,
QualType FromIntType,
674 bool ToNullPtr,
Expr *ToExpr,
bool FromDefault,
bool ToDefault) {
675 assert(FlatTree[CurrentNode].
Kind == Invalid &&
"Node is not empty.");
676 FlatTree[CurrentNode].Kind = FromIntegerAndToDeclaration;
677 FlatTree[CurrentNode].FromArgInfo.Val = FromInt;
678 FlatTree[CurrentNode].FromArgInfo.IsValidInt = IsValidFromInt;
679 FlatTree[CurrentNode].FromArgInfo.ArgType = FromIntType;
680 FlatTree[CurrentNode].FromArgInfo.ArgExpr = FromExpr;
681 FlatTree[CurrentNode].ToArgInfo.VD = ToValueDecl;
682 FlatTree[CurrentNode].ToArgInfo.NeedAddressOf = ToAddressOf;
683 FlatTree[CurrentNode].ToArgInfo.IsNullPtr = ToNullPtr;
684 FlatTree[CurrentNode].ToArgInfo.ArgExpr = ToExpr;
685 SetDefault(FromDefault, ToDefault);
689 void SetDefault(
bool FromDefault,
bool ToDefault) {
690 assert((!FromDefault || !ToDefault) &&
"Both arguments cannot be default.");
691 FlatTree[CurrentNode].FromArgInfo.IsDefault = FromDefault;
692 FlatTree[CurrentNode].ToArgInfo.IsDefault = ToDefault;
696 void SetSame(
bool Same) {
697 FlatTree[CurrentNode].Same = Same;
701 void SetKind(DiffKind
Kind) {
702 FlatTree[CurrentNode].Kind =
Kind;
707 assert(FlatTree[CurrentNode].
Kind != Invalid &&
708 "Cannot exit node before setting node information.");
709 CurrentNode = FlatTree[CurrentNode].ParentNode;
715 assert(FlatTree[CurrentNode].
Kind == Template &&
716 "Only Template nodes can have children nodes.");
717 FlatTree.push_back(DiffNode(CurrentNode));
718 DiffNode &
Node = FlatTree[CurrentNode];
719 if (Node.ChildNode == 0) {
721 Node.ChildNode = NextFreeNode;
726 for (i = Node.ChildNode; FlatTree[i].NextNode != 0;
727 i = FlatTree[i].NextNode) {
729 FlatTree[i].NextNode = NextFreeNode;
731 CurrentNode = NextFreeNode;
737 void StartTraverse() {
739 CurrentNode = NextFreeNode;
745 ReadNode = FlatTree[ReadNode].ParentNode;
750 assert(FlatTree[ReadNode].
Kind == Template &&
"Unexpected kind.");
751 FromTD = FlatTree[ReadNode].FromArgInfo.TD;
752 ToTD = FlatTree[ReadNode].ToArgInfo.TD;
753 FromQual = FlatTree[ReadNode].FromArgInfo.Qual;
754 ToQual = FlatTree[ReadNode].ToArgInfo.Qual;
758 assert(FlatTree[ReadNode].
Kind ==
Type &&
"Unexpected kind");
759 FromType = FlatTree[ReadNode].FromArgInfo.ArgType;
760 ToType = FlatTree[ReadNode].ToArgInfo.ArgType;
763 void GetExpressionDiff(
Expr *&FromExpr,
Expr *&ToExpr) {
764 assert(FlatTree[ReadNode].
Kind == Expression &&
"Unexpected kind");
765 FromExpr = FlatTree[ReadNode].FromArgInfo.ArgExpr;
766 ToExpr = FlatTree[ReadNode].ToArgInfo.ArgExpr;
770 assert(FlatTree[ReadNode].
Kind == TemplateTemplate &&
"Unexpected kind.");
771 FromTD = FlatTree[ReadNode].FromArgInfo.TD;
772 ToTD = FlatTree[ReadNode].ToArgInfo.TD;
775 void GetIntegerDiff(llvm::APSInt &FromInt, llvm::APSInt &ToInt,
776 bool &IsValidFromInt,
bool &IsValidToInt,
779 assert(FlatTree[ReadNode].
Kind == Integer &&
"Unexpected kind.");
780 FromInt = FlatTree[ReadNode].FromArgInfo.Val;
781 ToInt = FlatTree[ReadNode].ToArgInfo.Val;
782 IsValidFromInt = FlatTree[ReadNode].FromArgInfo.IsValidInt;
783 IsValidToInt = FlatTree[ReadNode].ToArgInfo.IsValidInt;
784 FromIntType = FlatTree[ReadNode].FromArgInfo.ArgType;
785 ToIntType = FlatTree[ReadNode].ToArgInfo.ArgType;
786 FromExpr = FlatTree[ReadNode].FromArgInfo.ArgExpr;
787 ToExpr = FlatTree[ReadNode].ToArgInfo.ArgExpr;
791 bool &FromAddressOf,
bool &ToAddressOf,
792 bool &FromNullPtr,
bool &ToNullPtr,
Expr *&FromExpr,
794 assert(FlatTree[ReadNode].
Kind == Declaration &&
"Unexpected kind.");
795 FromValueDecl = FlatTree[ReadNode].FromArgInfo.VD;
796 ToValueDecl = FlatTree[ReadNode].ToArgInfo.VD;
797 FromAddressOf = FlatTree[ReadNode].FromArgInfo.NeedAddressOf;
798 ToAddressOf = FlatTree[ReadNode].ToArgInfo.NeedAddressOf;
799 FromNullPtr = FlatTree[ReadNode].FromArgInfo.IsNullPtr;
800 ToNullPtr = FlatTree[ReadNode].ToArgInfo.IsNullPtr;
801 FromExpr = FlatTree[ReadNode].FromArgInfo.ArgExpr;
802 ToExpr = FlatTree[ReadNode].ToArgInfo.ArgExpr;
805 void GetFromDeclarationAndToIntegerDiff(
806 ValueDecl *&FromValueDecl,
bool &FromAddressOf,
bool &FromNullPtr,
807 Expr *&FromExpr, llvm::APSInt &ToInt,
bool &IsValidToInt,
809 assert(FlatTree[ReadNode].
Kind == FromDeclarationAndToInteger &&
811 FromValueDecl = FlatTree[ReadNode].FromArgInfo.VD;
812 FromAddressOf = FlatTree[ReadNode].FromArgInfo.NeedAddressOf;
813 FromNullPtr = FlatTree[ReadNode].FromArgInfo.IsNullPtr;
814 FromExpr = FlatTree[ReadNode].FromArgInfo.ArgExpr;
815 ToInt = FlatTree[ReadNode].ToArgInfo.Val;
816 IsValidToInt = FlatTree[ReadNode].ToArgInfo.IsValidInt;
817 ToIntType = FlatTree[ReadNode].ToArgInfo.ArgType;
818 ToExpr = FlatTree[ReadNode].ToArgInfo.ArgExpr;
821 void GetFromIntegerAndToDeclarationDiff(
822 llvm::APSInt &FromInt,
bool &IsValidFromInt,
QualType &FromIntType,
824 bool &ToNullPtr,
Expr *&ToExpr) {
825 assert(FlatTree[ReadNode].
Kind == FromIntegerAndToDeclaration &&
827 FromInt = FlatTree[ReadNode].FromArgInfo.Val;
828 IsValidFromInt = FlatTree[ReadNode].FromArgInfo.IsValidInt;
829 FromIntType = FlatTree[ReadNode].FromArgInfo.ArgType;
830 FromExpr = FlatTree[ReadNode].FromArgInfo.ArgExpr;
831 ToValueDecl = FlatTree[ReadNode].ToArgInfo.VD;
832 ToAddressOf = FlatTree[ReadNode].ToArgInfo.NeedAddressOf;
833 ToNullPtr = FlatTree[ReadNode].ToArgInfo.IsNullPtr;
834 ToExpr = FlatTree[ReadNode].ToArgInfo.ArgExpr;
839 return FlatTree[ReadNode].FromArgInfo.IsDefault;
844 return FlatTree[ReadNode].ToArgInfo.IsDefault;
849 return FlatTree[ReadNode].Same;
854 return FlatTree[ReadNode].ChildNode != 0;
859 ReadNode = FlatTree[ReadNode].ChildNode;
864 bool AdvanceSibling() {
865 if (FlatTree[ReadNode].NextNode == 0)
868 ReadNode = FlatTree[ReadNode].NextNode;
873 bool HasNextSibling() {
874 return FlatTree[ReadNode].NextNode != 0;
884 return FlatTree[ReadNode].Kind;
901 struct InternalIterator {
919 : TST(TST), Index(0), CurrentTA(nullptr), EndTA(nullptr) {
931 if (CurrentTA != EndTA)
return;
940 return Index >= TST->getNumArgs();
944 InternalIterator &operator++() {
950 if (CurrentTA != EndTA) {
952 if (CurrentTA != EndTA)
959 if (++Index == TST->getNumArgs())
972 if (CurrentTA != EndTA)
980 assert(!isEnd() &&
"Index exceeds number of arguments.");
981 if (CurrentTA == EndTA)
982 return TST->getArg(Index);
988 pointer operator->()
const {
993 InternalIterator SugaredIterator;
994 InternalIterator DesugaredIterator;
998 : SugaredIterator(TST),
1000 GetTemplateSpecializationType(Context, TST->
desugar())) {}
1003 TSTiterator &operator++() {
1005 ++DesugaredIterator;
1011 return *SugaredIterator;
1015 pointer operator->()
const {
1020 bool isEnd()
const {
1021 return SugaredIterator.isEnd();
1026 bool hasDesugaredTA()
const {
1027 return !DesugaredIterator.isEnd();
1031 reference getDesugaredTA()
const {
1032 return *DesugaredIterator;
1076 FromArgTST = GetTemplateSpecializationType(Context, FromType);
1077 ToArgTST = GetTemplateSpecializationType(Context, ToType);
1079 if (!FromArgTST || !ToArgTST)
1082 if (!hasSameTemplate(FromArgTST, ToArgTST))
1089 void DiffTypes(
const TSTiterator &FromIter,
const TSTiterator &ToIter) {
1090 QualType FromType = GetType(FromIter);
1093 bool FromDefault = FromIter.isEnd() && !FromType.
isNull();
1094 bool ToDefault = ToIter.isEnd() && !ToType.
isNull();
1098 if (OnlyPerformTypeDiff(Context, FromType, ToType, FromArgTST, ToArgTST)) {
1099 Tree.SetTypeDiff(FromType, ToType, FromDefault, ToDefault);
1103 assert(FromArgTST && ToArgTST &&
1104 "Both template specializations need to be valid.");
1109 Tree.SetTemplateDiff(FromArgTST->getTemplateName().getAsTemplateDecl(),
1110 ToArgTST->getTemplateName().getAsTemplateDecl(),
1111 FromQual, ToQual, FromDefault, ToDefault);
1112 DiffTemplate(FromArgTST, ToArgTST);
1118 void DiffTemplateTemplates(
const TSTiterator &FromIter,
1119 const TSTiterator &ToIter) {
1122 Tree.SetTemplateTemplateDiff(FromDecl, ToDecl, FromIter.isEnd() && FromDecl,
1123 ToIter.isEnd() && ToDecl);
1124 Tree.SetSame(FromDecl && ToDecl &&
1129 static void InitializeNonTypeDiffVariables(
ASTContext &Context,
1130 const TSTiterator &Iter,
1132 llvm::APSInt &
Value,
bool &HasInt,
1133 QualType &IntType,
bool &IsNullPtr,
1135 bool &NeedAddressOf) {
1136 if (!Iter.isEnd()) {
1137 switch (Iter->getKind()) {
1139 llvm_unreachable(
"unknown ArgumentKind");
1141 Value = Iter->getAsIntegral();
1143 IntType = Iter->getIntegralType();
1146 VD = Iter->getAsDecl();
1147 QualType ArgType = Iter->getParamTypeForDecl();
1151 NeedAddressOf =
true;
1158 E = Iter->getAsExpr();
1164 if (!Iter.hasDesugaredTA())
return;
1169 llvm_unreachable(
"unknown ArgumentKind");
1181 NeedAddressOf =
true;
1199 void DiffNonTypes(
const TSTiterator &FromIter,
const TSTiterator &ToIter,
1202 Expr *FromExpr =
nullptr, *ToExpr =
nullptr;
1203 llvm::APSInt FromInt, ToInt;
1205 ValueDecl *FromValueDecl =
nullptr, *ToValueDecl =
nullptr;
1206 bool HasFromInt =
false, HasToInt =
false, FromNullPtr =
false,
1207 ToNullPtr =
false, NeedFromAddressOf =
false, NeedToAddressOf =
false;
1208 InitializeNonTypeDiffVariables(
1209 Context, FromIter, FromDefaultNonTypeDecl, FromInt, HasFromInt,
1210 FromIntType, FromNullPtr, FromExpr, FromValueDecl, NeedFromAddressOf);
1211 InitializeNonTypeDiffVariables(Context, ToIter, ToDefaultNonTypeDecl, ToInt,
1212 HasToInt, ToIntType, ToNullPtr, ToExpr,
1213 ToValueDecl, NeedToAddressOf);
1215 bool FromDefault = FromIter.isEnd() &&
1216 (FromExpr || FromValueDecl || HasFromInt || FromNullPtr);
1217 bool ToDefault = ToIter.isEnd() &&
1218 (ToExpr || ToValueDecl || HasToInt || ToNullPtr);
1220 bool FromDeclaration = FromValueDecl || FromNullPtr;
1221 bool ToDeclaration = ToValueDecl || ToNullPtr;
1223 if (FromDeclaration && HasToInt) {
1224 Tree.SetFromDeclarationAndToIntegerDiff(
1225 FromValueDecl, NeedFromAddressOf, FromNullPtr, FromExpr, ToInt,
1226 HasToInt, ToIntType, ToExpr, FromDefault, ToDefault);
1227 Tree.SetSame(
false);
1232 if (HasFromInt && ToDeclaration) {
1233 Tree.SetFromIntegerAndToDeclarationDiff(
1234 FromInt, HasFromInt, FromIntType, FromExpr, ToValueDecl,
1235 NeedToAddressOf, ToNullPtr, ToExpr, FromDefault, ToDefault);
1236 Tree.SetSame(
false);
1240 if (HasFromInt || HasToInt) {
1241 Tree.SetIntegerDiff(FromInt, ToInt, HasFromInt, HasToInt, FromIntType,
1242 ToIntType, FromExpr, ToExpr, FromDefault, ToDefault);
1243 if (HasFromInt && HasToInt) {
1244 Tree.SetSame(Context.
hasSameType(FromIntType, ToIntType) &&
1250 if (FromDeclaration || ToDeclaration) {
1251 Tree.SetDeclarationDiff(FromValueDecl, ToValueDecl, NeedFromAddressOf,
1252 NeedToAddressOf, FromNullPtr, ToNullPtr, FromExpr,
1253 ToExpr, FromDefault, ToDefault);
1254 bool BothNull = FromNullPtr && ToNullPtr;
1255 bool SameValueDecl =
1256 FromValueDecl && ToValueDecl &&
1257 NeedFromAddressOf == NeedToAddressOf &&
1259 Tree.SetSame(BothNull || SameValueDecl);
1263 assert((FromExpr || ToExpr) &&
"Both template arguments cannot be empty.");
1264 Tree.SetExpressionDiff(FromExpr, ToExpr, FromDefault, ToDefault);
1265 Tree.SetSame(IsEqualExpr(Context, FromExpr, ToExpr));
1274 FromTST->getTemplateName().getAsTemplateDecl()->getTemplateParameters();
1276 ToTST->getTemplateName().getAsTemplateDecl()->getTemplateParameters();
1277 unsigned TotalArgs = 0;
1278 for (TSTiterator FromIter(Context, FromTST), ToIter(Context, ToTST);
1279 !FromIter.isEnd() || !ToIter.isEnd(); ++TotalArgs) {
1285 unsigned FromParamIndex = std::min(TotalArgs, ParamsFrom->
size() - 1);
1286 unsigned ToParamIndex = std::min(TotalArgs, ParamsTo->
size() - 1);
1290 assert(FromParamND->getKind() == ToParamND->
getKind() &&
1291 "Parameter Decl are not the same kind.");
1293 if (isa<TemplateTypeParmDecl>(FromParamND)) {
1294 DiffTypes(FromIter, ToIter);
1295 }
else if (isa<TemplateTemplateParmDecl>(FromParamND)) {
1296 DiffTemplateTemplates(FromIter, ToIter);
1297 }
else if (isa<NonTypeTemplateParmDecl>(FromParamND)) {
1299 cast<NonTypeTemplateParmDecl>(FromParamND);
1301 cast<NonTypeTemplateParmDecl>(ToParamND);
1302 DiffNonTypes(FromIter, ToIter, FromDefaultNonTypeDecl,
1303 ToDefaultNonTypeDecl);
1305 llvm_unreachable(
"Unexpected Decl type.");
1315 static void makeTemplateList(
1319 TemplateList.push_back(TST);
1320 if (!TST->isTypeAlias())
1330 return FromTST->getTemplateName().getAsTemplateDecl()->getCanonicalDecl() ==
1331 ToTST->getTemplateName().getAsTemplateDecl()->getCanonicalDecl();
1341 if (hasSameBaseTemplate(FromTST, ToTST))
1348 makeTemplateList(FromTemplateList, FromTST);
1349 makeTemplateList(ToTemplateList, ToTST);
1352 FromIter = FromTemplateList.rbegin(), FromEnd = FromTemplateList.rend(),
1353 ToIter = ToTemplateList.rbegin(), ToEnd = ToTemplateList.rend();
1356 if (!hasSameBaseTemplate(*FromIter, *ToIter))
1362 for (; FromIter != FromEnd && ToIter != ToEnd; ++FromIter, ++ToIter) {
1363 if (!hasSameBaseTemplate(*FromIter, *ToIter))
1367 FromTST = FromIter[-1];
1375 static QualType GetType(
const TSTiterator &Iter) {
1377 return Iter->getAsType();
1378 if (Iter.hasDesugaredTA())
1379 return Iter.getDesugaredTA().getAsType();
1385 static TemplateDecl *GetTemplateDecl(
const TSTiterator &Iter) {
1387 return Iter->getAsTemplate().getAsTemplateDecl();
1388 if (Iter.hasDesugaredTA())
1389 return Iter.getDesugaredTA().getAsTemplate().getAsTemplateDecl();
1397 if (FromExpr == ToExpr)
1400 if (!FromExpr || !ToExpr)
1403 llvm::FoldingSetNodeID FromID, ToID;
1404 FromExpr->Profile(FromID, Context,
true);
1405 ToExpr->Profile(ToID, Context,
true);
1406 return FromID == ToID;
1414 void TreeToString(
int Indent = 1) {
1423 switch (Tree.GetKind()) {
1424 case DiffTree::Invalid:
1425 llvm_unreachable(
"Template diffing failed with bad DiffNode");
1426 case DiffTree::Type: {
1428 Tree.GetTypeDiff(FromType, ToType);
1429 PrintTypeNames(FromType, ToType, Tree.FromDefault(), Tree.ToDefault(),
1433 case DiffTree::Expression: {
1434 Expr *FromExpr, *ToExpr;
1435 Tree.GetExpressionDiff(FromExpr, ToExpr);
1436 PrintExpr(FromExpr, ToExpr, Tree.FromDefault(), Tree.ToDefault(),
1440 case DiffTree::TemplateTemplate: {
1442 Tree.GetTemplateTemplateDiff(FromTD, ToTD);
1443 PrintTemplateTemplate(FromTD, ToTD, Tree.FromDefault(),
1444 Tree.ToDefault(), Tree.NodeIsSame());
1447 case DiffTree::Integer: {
1448 llvm::APSInt FromInt, ToInt;
1449 Expr *FromExpr, *ToExpr;
1450 bool IsValidFromInt, IsValidToInt;
1452 Tree.GetIntegerDiff(FromInt, ToInt, IsValidFromInt, IsValidToInt,
1453 FromIntType, ToIntType, FromExpr, ToExpr);
1454 PrintAPSInt(FromInt, ToInt, IsValidFromInt, IsValidToInt, FromIntType,
1455 ToIntType, FromExpr, ToExpr, Tree.FromDefault(),
1456 Tree.ToDefault(), Tree.NodeIsSame());
1459 case DiffTree::Declaration: {
1461 bool FromAddressOf, ToAddressOf;
1462 bool FromNullPtr, ToNullPtr;
1463 Expr *FromExpr, *ToExpr;
1464 Tree.GetDeclarationDiff(FromValueDecl, ToValueDecl, FromAddressOf,
1465 ToAddressOf, FromNullPtr, ToNullPtr, FromExpr,
1467 PrintValueDecl(FromValueDecl, ToValueDecl, FromAddressOf, ToAddressOf,
1468 FromNullPtr, ToNullPtr, FromExpr, ToExpr,
1469 Tree.FromDefault(), Tree.ToDefault(), Tree.NodeIsSame());
1472 case DiffTree::FromDeclarationAndToInteger: {
1481 Tree.GetFromDeclarationAndToIntegerDiff(
1482 FromValueDecl, FromAddressOf, FromNullPtr, FromExpr, ToInt,
1483 IsValidToInt, ToIntType, ToExpr);
1484 assert((FromValueDecl || FromNullPtr) && IsValidToInt);
1485 PrintValueDeclAndInteger(FromValueDecl, FromAddressOf, FromNullPtr,
1486 FromExpr, Tree.FromDefault(), ToInt, ToIntType,
1487 ToExpr, Tree.ToDefault());
1490 case DiffTree::FromIntegerAndToDeclaration: {
1491 llvm::APSInt FromInt;
1492 bool IsValidFromInt;
1499 Tree.GetFromIntegerAndToDeclarationDiff(
1500 FromInt, IsValidFromInt, FromIntType, FromExpr, ToValueDecl,
1501 ToAddressOf, ToNullPtr, ToExpr);
1502 assert(IsValidFromInt && (ToValueDecl || ToNullPtr));
1503 PrintIntegerAndValueDecl(FromInt, FromIntType, FromExpr,
1504 Tree.FromDefault(), ToValueDecl, ToAddressOf,
1505 ToNullPtr, ToExpr, Tree.ToDefault());
1508 case DiffTree::Template: {
1512 Tree.GetTemplateDiff(FromTD, ToTD, FromQual, ToQual);
1514 PrintQualifiers(FromQual, ToQual);
1516 if (!Tree.HasChildren()) {
1525 unsigned NumElideArgs = 0;
1528 if (Tree.NodeIsSame()) {
1532 if (NumElideArgs > 0) {
1533 PrintElideArgs(NumElideArgs,
Indent);
1539 if (Tree.HasNextSibling())
1541 }
while (Tree.AdvanceSibling());
1542 if (NumElideArgs > 0)
1543 PrintElideArgs(NumElideArgs,
Indent);
1558 assert(!IsBold &&
"Attempting to bold text that is already bold.");
1566 assert(IsBold &&
"Attempting to remove bold from unbold text.");
1578 bool FromDefault,
bool ToDefault,
bool Same) {
1580 "Only one template argument may be missing.");
1592 PrintQualifiers(FromQual, ToQual);
1597 std::string FromTypeStr = FromType.
isNull() ?
"(no argument)"
1599 std::string ToTypeStr = ToType.
isNull() ?
"(no argument)"
1603 if (FromTypeStr == ToTypeStr) {
1604 std::string FromCanTypeStr =
1607 if (FromCanTypeStr != ToCanTypeStr) {
1608 FromTypeStr = FromCanTypeStr;
1609 ToTypeStr = ToCanTypeStr;
1613 if (PrintTree) OS <<
'[';
1614 OS << (FromDefault ?
"(default) " :
"");
1619 OS <<
" != " << (ToDefault ?
"(default) " :
"");
1630 void PrintExpr(
const Expr *FromExpr,
const Expr *ToExpr,
bool FromDefault,
1631 bool ToDefault,
bool Same) {
1632 assert((FromExpr || ToExpr) &&
1633 "Only one template argument may be missing.");
1635 PrintExpr(FromExpr);
1636 }
else if (!PrintTree) {
1637 OS << (FromDefault ?
"(default) " :
"");
1639 PrintExpr(FromExpr);
1642 OS << (FromDefault ?
"[(default) " :
"[");
1644 PrintExpr(FromExpr);
1646 OS <<
" != " << (ToDefault ?
"(default) " :
"");
1655 void PrintExpr(
const Expr *E) {
1657 E->printPretty(OS,
nullptr, Policy);
1660 OS <<
"(no argument)";
1666 bool FromDefault,
bool ToDefault,
bool Same) {
1667 assert((FromTD || ToTD) &&
"Only one template argument may be missing.");
1669 std::string FromName = FromTD ? FromTD->
getName() :
"(no argument)";
1670 std::string ToName = ToTD ? ToTD->
getName() :
"(no argument)";
1671 if (FromTD && ToTD && FromName == ToName) {
1678 }
else if (!PrintTree) {
1679 OS << (FromDefault ?
"(default) template " :
"template ");
1684 OS << (FromDefault ?
"[(default) template " :
"[template ");
1688 OS <<
" != " << (ToDefault ?
"(default) template " :
"template ");
1698 void PrintAPSInt(llvm::APSInt FromInt, llvm::APSInt ToInt,
1699 bool IsValidFromInt,
bool IsValidToInt,
QualType FromIntType,
1701 bool FromDefault,
bool ToDefault,
bool Same) {
1702 assert((IsValidFromInt || IsValidToInt) &&
1703 "Only one integral argument may be missing.");
1707 OS << ((FromInt == 0) ?
"false" :
"true");
1709 OS << FromInt.toString(10);
1714 bool PrintType = IsValidFromInt && IsValidToInt &&
1718 OS << (FromDefault ?
"(default) " :
"");
1719 PrintAPSInt(FromInt, FromExpr, IsValidFromInt, FromIntType, PrintType);
1721 OS << (FromDefault ?
"[(default) " :
"[");
1722 PrintAPSInt(FromInt, FromExpr, IsValidFromInt, FromIntType, PrintType);
1723 OS <<
" != " << (ToDefault ?
"(default) " :
"");
1724 PrintAPSInt(ToInt, ToExpr, IsValidToInt, ToIntType, PrintType);
1731 void PrintAPSInt(llvm::APSInt Val,
Expr *E,
bool Valid,
QualType IntType,
1735 if (HasExtraInfo(E)) {
1751 OS << ((Val == 0) ?
"false" :
"true");
1753 OS << Val.toString(10);
1758 OS <<
"(no argument)";
1765 bool HasExtraInfo(
Expr *E) {
1766 if (!E)
return false;
1770 if (isa<IntegerLiteral>(E))
return false;
1774 if (isa<IntegerLiteral>(UO->getSubExpr()))
1777 if (isa<CXXBoolLiteralExpr>(E))
1783 void PrintValueDecl(
ValueDecl *VD,
bool AddressOf,
Expr *E,
bool NullPtr) {
1792 if (E && !isa<CXXNullPtrLiteralExpr>(E)) {
1807 OS <<
"(no argument)";
1813 bool FromAddressOf,
bool ToAddressOf,
bool FromNullPtr,
1814 bool ToNullPtr,
Expr *FromExpr,
Expr *ToExpr,
1815 bool FromDefault,
bool ToDefault,
bool Same) {
1816 assert((FromValueDecl || FromNullPtr || ToValueDecl || ToNullPtr) &&
1817 "Only one Decl argument may be NULL");
1820 PrintValueDecl(FromValueDecl, FromAddressOf, FromExpr, FromNullPtr);
1821 }
else if (!PrintTree) {
1822 OS << (FromDefault ?
"(default) " :
"");
1824 PrintValueDecl(FromValueDecl, FromAddressOf, FromExpr, FromNullPtr);
1827 OS << (FromDefault ?
"[(default) " :
"[");
1829 PrintValueDecl(FromValueDecl, FromAddressOf, FromExpr, FromNullPtr);
1831 OS <<
" != " << (ToDefault ?
"(default) " :
"");
1833 PrintValueDecl(ToValueDecl, ToAddressOf, ToExpr, ToNullPtr);
1842 void PrintValueDeclAndInteger(
ValueDecl *VD,
bool NeedAddressOf,
1843 bool IsNullPtr,
Expr *VDExpr,
bool DefaultDecl,
1844 llvm::APSInt Val,
QualType IntType,
1845 Expr *IntExpr,
bool DefaultInt) {
1847 OS << (DefaultDecl ?
"(default) " :
"");
1849 PrintValueDecl(VD, NeedAddressOf, VDExpr, IsNullPtr);
1852 OS << (DefaultDecl ?
"[(default) " :
"[");
1854 PrintValueDecl(VD, NeedAddressOf, VDExpr, IsNullPtr);
1856 OS <<
" != " << (DefaultInt ?
"(default) " :
"");
1857 PrintAPSInt(Val, IntExpr,
true , IntType,
false );
1864 void PrintIntegerAndValueDecl(llvm::APSInt Val,
QualType IntType,
1866 bool NeedAddressOf,
bool IsNullPtr,
1867 Expr *VDExpr,
bool DefaultDecl) {
1869 OS << (DefaultInt ?
"(default) " :
"");
1870 PrintAPSInt(Val, IntExpr,
true , IntType,
false );
1872 OS << (DefaultInt ?
"[(default) " :
"[");
1873 PrintAPSInt(Val, IntExpr,
true , IntType,
false );
1874 OS <<
" != " << (DefaultDecl ?
"(default) " :
"");
1876 PrintValueDecl(VD, NeedAddressOf, VDExpr, IsNullPtr);
1883 void PrintElideArgs(
unsigned NumElideArgs,
unsigned Indent) {
1886 for (
unsigned i = 0; i <
Indent; ++i)
1889 if (NumElideArgs == 0)
return;
1890 if (NumElideArgs == 1)
1893 OS <<
"[" << NumElideArgs <<
" * ...]";
1903 if (FromQual == ToQual) {
1904 PrintQualifier(FromQual,
false);
1924 if (CommonQual.
empty() && FromQual.
empty()) {
1926 OS <<
"(no qualifiers) ";
1929 PrintQualifier(CommonQual,
false);
1930 PrintQualifier(FromQual,
true);
1935 OS <<
"(no qualifiers)";
1938 PrintQualifier(CommonQual,
false,
1940 PrintQualifier(ToQual,
true,
1945 PrintQualifier(CommonQual,
false);
1946 PrintQualifier(FromQual,
true);
1950 void PrintQualifier(
Qualifiers Q,
bool ApplyBold,
1951 bool AppendSpaceIfNonEmpty =
true) {
1952 if (Q.
empty())
return;
1953 if (ApplyBold) Bold();
1954 Q.
print(OS, Policy, AppendSpaceIfNonEmpty);
1955 if (ApplyBold) Unbold();
1961 QualType ToType,
bool PrintTree,
bool PrintFromType,
1962 bool ElideType,
bool ShowColor)
1964 Policy(Context.getLangOpts()),
1965 ElideType(ElideType),
1966 PrintTree(PrintTree),
1967 ShowColor(ShowColor),
1969 FromTemplateType(PrintFromType ? FromType : ToType),
1970 ToTemplateType(PrintFromType ? ToType : FromType),
1976 void DiffTemplate() {
1977 Qualifiers FromQual = FromTemplateType.getQualifiers(),
1978 ToQual = ToTemplateType.getQualifiers();
1981 GetTemplateSpecializationType(Context, FromTemplateType);
1983 GetTemplateSpecializationType(Context, ToTemplateType);
1986 if (!FromOrigTST || !ToOrigTST)
1990 if (!hasSameTemplate(FromOrigTST, ToOrigTST)) {
1998 Tree.SetTemplateDiff(FromOrigTST->getTemplateName().getAsTemplateDecl(),
1999 ToOrigTST->getTemplateName().getAsTemplateDecl(),
2000 FromQual, ToQual,
false ,
2003 DiffTemplate(FromOrigTST, ToOrigTST);
2010 Tree.StartTraverse();
2015 assert(!IsBold &&
"Bold is applied to end of string.");
2026 bool PrintFromType,
bool ElideType,
2027 bool ShowColors, raw_ostream &OS) {
2029 PrintFromType =
true;
2030 TemplateDiff TD(OS, Context, FromType, ToType, PrintTree, PrintFromType,
2031 ElideType, ShowColors);
unsigned getNumElements() const
Defines the clang::ASTContext interface.
Represents a type that was referred to using an elaborated type keyword, e.g., struct S...
Qualifiers getLocalQualifiers() const
Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...
StringRef getName() const
getName - Get the name of identifier for this declaration as a StringRef.
PointerType - C99 6.7.5.1 - Pointer Declarators.
A (possibly-)qualified type.
llvm::APSInt getAsIntegral() const
Retrieve the template argument as an integral value.
FunctionType - C99 6.7.5.3 - Function Declarators.
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type...
C Language Family Type Representation.
The template argument is an expression, and we've not resolved it to one of the other forms yet...
Defines the C++ template declaration subclasses.
Represents a C++11 auto or C++14 decltype(auto) type.
std::string getAsString() const
pack_iterator pack_begin() const
Iterator referencing the first argument of a template argument pack.
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type...
TemplateSpecializationType(TemplateName T, const TemplateArgument *Args, unsigned NumArgs, QualType Canon, QualType Aliased)
The base class of the type hierarchy.
The template argument is a declaration that was provided for a pointer, reference, or pointer to member non-type template parameter.
NamedDecl * getParam(unsigned Idx)
bool isBooleanType() const
Expr * getAsExpr() const
Retrieve the template argument as an expression.
This file provides some common utility functions for processing Lambda related AST Constructs...
QualType getObjCClassType() const
Represents the Objective-C Class type.
Stores a list of template parameters for a TemplateDecl and its derived classes.
Describes how types, statements, expressions, and declarations should be printed. ...
Represents the result of substituting a type for a template type parameter.
Defines the clang::Expr interface and subclasses for C++ expressions.
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like 'int()'.
The collection of all-type qualifiers we support.
Expr * IgnoreImpCasts() LLVM_READONLY
IgnoreImpCasts - Skip past any implicit casts which might surround this expression.
static std::string ConvertTypeToDiagnosticString(ASTContext &Context, QualType Ty, ArrayRef< DiagnosticsEngine::ArgumentValue > PrevArgs, ArrayRef< intptr_t > QualTypeVals)
Convert the given type to a string suitable for printing as part of a diagnostic. ...
Represents a class template specialization, which refers to a class template with a given set of temp...
QualType apply(const ASTContext &Context, QualType QT) const
Apply the collected qualifiers to the given type.
Represents a class type in Objective C.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
bool isTranslationUnit() const
unsigned size() const
Retrieve the number of template arguments in this template argument list.
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
clang::CharUnits operator*(clang::CharUnits::QuantityType Scale, const clang::CharUnits &CU)
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
virtual void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const
getNameForDiagnostic - Appends a human-readable name for this declaration into the given stream...
An rvalue reference type, per C++11 [dcl.ref].
param_type_range param_types() const
bool isParameterPack() const
Whether this parameter is a non-type template parameter pack.
const LangOptions & getLangOpts() const
TypeDecl - Represents a declaration of a type.
RecordDecl * getDecl() const
std::string getNameAsString() const
getNameAsString - Get a human-readable name for the declaration, even if it is one of the special kin...
static Qualifiers removeCommonQualifiers(Qualifiers &L, Qualifiers &R)
Returns the common set of qualifiers while removing them from the given sets.
TypeClass getTypeClass() const
void print(raw_ostream &OS, const PrintingPolicy &Policy, bool appendSpaceIfNonEmpty=false) const
bool isLambdaCallOperator(const CXXMethodDecl *MD)
detail::InMemoryDirectory::const_iterator I
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
QualType getTemplateSpecializationType(TemplateName T, const TemplateArgument *Args, unsigned NumArgs, QualType Canon=QualType()) const
QualType getObjCObjectType(QualType Base, ObjCProtocolDecl *const *Protocols, unsigned NumProtocols) const
Legacy interface: cannot provide type arguments or __kindof.
Represents a prototype with parameter type info, e.g.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Expr - This represents one expression.
static Kind getNullabilityAttrKind(NullabilityKind kind)
Retrieve the attribute kind corresponding to the given nullability kind.
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
ArgKind getKind() const
Return the kind of stored template argument.
ExtProtoInfo getExtProtoInfo() const
unsigned TemplateDiffUsed
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
Represents a C++ template name within the type system.
static DeclarationName getFromOpaqueInteger(uintptr_t P)
static Optional< NullabilityKind > stripOuterNullability(QualType &T)
Strip off the top-level nullability annotation on the given type, if it's there.
void print(raw_ostream &OS, const PrintingPolicy &Policy, const Twine &PlaceHolder=Twine()) const
QualType getObjCIdType() const
Represents the Objective-CC id type.
const TemplateArgument * data() const
Retrieve a pointer to the template argument list.
UnaryOperator - This represents the unary-expression's (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Represents a GCC generic vector type.
An lvalue reference type, per C++11 [dcl.ref].
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
QualType getElementType() const
static QualType Desugar(ASTContext &Context, QualType QT, bool &ShouldAKA)
const clang::PrintingPolicy & getPrintingPolicy() const
const char * getSpelling() const
Sugar for parentheses used when specifying types.
const char ToggleHighlight
Special character that the diagnostic printer will use to toggle the bold attribute.
OpenMPLinearClauseKind Modifier
Modifier of 'linear' clause.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
Expr * getDefaultArgument() const
Retrieve the default argument, if any.
QualType getAttributedType(AttributedType::Kind attrKind, QualType modifiedType, QualType equivalentType)
bool isVectorType() const
static QualType getFromOpaquePtr(const void *Ptr)
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
QualType getObjCSelType() const
Retrieve the type that corresponds to the predefined Objective-C 'SEL' type.
ast_type_traits::DynTypedNode Node
Represents a template argument.
Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons...
QualType getAsType() const
Retrieve the type for a type template argument.
void print(raw_ostream &OS, const PrintingPolicy &Policy) const
Print this nested name specifier to the given output stream.
A qualifier set is used to build a set of qualifiers.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
The base class of all kinds of template declarations (e.g., class, function, etc.).
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
QualType getObjCProtoType() const
Retrieve the type of the Objective-C Protocol class.
const Type * strip(QualType type)
Collect any qualifiers on the given type and return an unqualified type.
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
detail::InMemoryDirectory::const_iterator E
QualType getBuiltinVaListType() const
Retrieve the type of the __builtin_va_list type.
Represents a pointer to an Objective C object.
QualType getBuiltinMSVaListType() const
Retrieve the type of the __builtin_ms_va_list type.
QualType getLocalUnqualifiedType() const
Return this type with all of the instance-specific qualifiers removed, but without removing any quali...
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
void FormatASTNodeDiagnosticArgument(DiagnosticsEngine::ArgumentKind Kind, intptr_t Val, StringRef Modifier, StringRef Argument, ArrayRef< DiagnosticsEngine::ArgumentValue > PrevArgs, SmallVectorImpl< char > &Output, void *Cookie, ArrayRef< intptr_t > QualTypeVals)
DiagnosticsEngine argument formatting function for diagnostics that involve AST nodes.
const T * getAs() const
Member-template getAs<specific type>'.
QualType getCanonicalType() const
QualType getIntegralType() const
Retrieve the type of the integral value.
The template argument is a type.
The template argument is actually a parameter pack.
std::string getQualifiedNameAsString() const
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the class template specialization.
An attributed type is a type to which a type attribute has been applied.
pack_iterator pack_end() const
Iterator referencing one past the last argument of a template argument pack.
QualType getParamTypeForDecl() const
NamedDecl - This represents a decl with a name.
static bool FormatTemplateTypeDiff(ASTContext &Context, QualType FromType, QualType ToType, bool PrintTree, bool PrintFromType, bool ElideType, bool ShowColors, raw_ostream &OS)
FormatTemplateTypeDiff - A helper static function to start the template diff and return the properly ...
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Attr - This represents one attribute.
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
bool isPointerType() const