23 #include "llvm/ADT/SmallString.h"
24 #include "llvm/Support/raw_ostream.h"
26 using namespace clang;
42 if (
const ParenType *PT = dyn_cast<ParenType>(Ty)) {
48 dyn_cast<SubstTemplateTypeParmType>(Ty)) {
58 if (
const AdjustedType *AT = dyn_cast<AdjustedType>(Ty)) {
63 if (
const AutoType *AT = dyn_cast<AutoType>(Ty)) {
72 if (
const FunctionType *FT = dyn_cast<FunctionType>(Ty)) {
73 bool DesugarReturn =
false;
74 QualType SugarRT = FT->getReturnType();
81 bool DesugarArgument =
false;
87 if (
auto nullability =
96 if (DesugarReturn || DesugarArgument) {
107 dyn_cast<TemplateSpecializationType>(Ty)) {
108 if (!TST->isTypeAlias()) {
109 bool DesugarArgument =
false;
111 for (
unsigned I = 0, N = TST->getNumArgs();
I != N; ++
I) {
119 if (DesugarArgument) {
122 TST->getTemplateName(), Args, QT);
142 bool IsSugar =
false;
144 #define ABSTRACT_TYPE(Class, Base)
145 #define TYPE(Class, Base) \
146 case Type::Class: { \
147 const Class##Type *CTy = cast<Class##Type>(Ty); \
148 if (CTy->isSugared()) { \
150 Underlying = CTy->desugar(); \
154 #include "clang/AST/TypeNodes.def"
163 if (isa<VectorType>(Underlying))
168 if (
const TypedefType *QTT = dyn_cast<TypedefType>(QT))
169 if (UTT->getDecl()->getTypedefNameForAnonDecl() == QTT->getDecl())
192 if (Ty->getBaseType().getTypePtr() != Ty && !ShouldAKA) {
195 llvm::makeArrayRef(Ty->qual_begin(),
196 Ty->getNumProtocols()),
197 Ty->isKindOfTypeAsWritten());
201 return QC.
apply(Context, QT);
233 bool ForceAKA =
false;
238 for (
unsigned I = 0,
E = QualTypeVals.size();
I !=
E; ++
I) {
246 if (CompareCanTy == CanTy)
249 bool ShouldAKA =
false;
251 std::string CompareDesugarStr =
253 if (CompareS != S && CompareDesugarStr != S)
256 std::string CompareCanS =
259 if (CompareCanS == CanS)
268 bool Repeated =
false;
269 for (
unsigned i = 0, e = PrevArgs.size(); i != e; ++i) {
272 void *Ptr = (
void*)PrevArgs[i].second;
284 bool ShouldAKA =
false;
286 if (ShouldAKA || ForceAKA) {
287 if (DesugaredTy == Ty) {
292 S =
"'" + S +
"' (aka '" + akaStr +
"')";
302 std::string DecoratedString;
303 llvm::raw_string_ostream OS(DecoratedString);
304 const char *Values = VTy->
getNumElements() > 1 ?
"values" :
"value";
305 OS <<
"'" << S <<
"' (vector of " << VTy->
getNumElements() <<
" '"
307 <<
"' " << Values <<
")";
318 bool PrintFromType,
bool ElideType,
319 bool ShowColors, raw_ostream &OS);
332 size_t OldEnd = Output.size();
333 llvm::raw_svector_ostream OS(Output);
334 bool NeedQuotes =
true;
337 default: llvm_unreachable(
"unknown ArgumentKind");
361 Modifier = StringRef();
362 Argument = StringRef();
366 assert(Modifier.empty() && Argument.empty() &&
367 "Invalid modifier for QualType argument");
375 if (Modifier ==
"objcclass" && Argument.empty())
377 else if (Modifier ==
"objcinstance" && Argument.empty())
380 assert(Modifier.empty() && Argument.empty() &&
381 "Invalid modifier for DeclarationName argument");
388 if (Modifier ==
"q" && Argument.empty())
391 assert(Modifier.empty() && Argument.empty() &&
392 "Invalid modifier for NamedDecl* argument");
407 assert(DC &&
"Should never have a null declaration context");
413 OS <<
"the global namespace";
415 OS <<
"the global scope";
417 OS <<
"block literal";
419 OS <<
"lambda expression";
423 PrevArgs, QualTypeVals);
425 assert(isa<NamedDecl>(DC) &&
"Expected a NamedDecl");
427 if (isa<NamespaceDecl>(ND))
429 else if (isa<ObjCMethodDecl>(ND))
431 else if (isa<FunctionDecl>(ND))
441 const Attr *At =
reinterpret_cast<Attr *
>(Val);
442 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(
const llvm::APSInt &FromInt,
const 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.");
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,
const 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 const 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) {
933 if (CurrentTA != EndTA)
return;
942 assert(TST &&
"InternalIterator is invalid with a null TST.");
943 return Index >= TST->getNumArgs();
947 InternalIterator &operator++() {
948 assert(TST &&
"InternalIterator is invalid with a null TST.");
954 if (CurrentTA != EndTA) {
956 if (CurrentTA != EndTA)
963 if (++Index == TST->getNumArgs())
976 if (CurrentTA != EndTA)
984 assert(TST &&
"InternalIterator is invalid with a null TST.");
985 assert(!isEnd() &&
"Index exceeds number of arguments.");
986 if (CurrentTA == EndTA)
987 return TST->getArg(Index);
993 pointer operator->()
const {
994 assert(TST &&
"InternalIterator is invalid with a null TST.");
999 bool UseDesugaredIterator;
1000 InternalIterator SugaredIterator;
1001 InternalIterator DesugaredIterator;
1006 SugaredIterator(TST),
1008 GetTemplateSpecializationType(Context, TST->
desugar())) {}
1011 TSTiterator &operator++() {
1013 if (UseDesugaredIterator)
1014 ++DesugaredIterator;
1020 return *SugaredIterator;
1024 pointer operator->()
const {
1029 bool isEnd()
const {
1030 return SugaredIterator.isEnd();
1035 bool hasDesugaredTA()
const {
1036 return UseDesugaredIterator && !DesugaredIterator.isEnd();
1040 reference getDesugaredTA()
const {
1041 assert(UseDesugaredIterator &&
1042 "Desugared TemplateArgument should not be used.");
1043 return *DesugaredIterator;
1086 FromArgTST = GetTemplateSpecializationType(Context, FromType);
1087 ToArgTST = GetTemplateSpecializationType(Context, ToType);
1089 if (!FromArgTST || !ToArgTST)
1092 if (!hasSameTemplate(FromArgTST, ToArgTST))
1099 void DiffTypes(
const TSTiterator &FromIter,
const TSTiterator &ToIter) {
1100 QualType FromType = GetType(FromIter);
1103 bool FromDefault = FromIter.isEnd() && !FromType.
isNull();
1104 bool ToDefault = ToIter.isEnd() && !ToType.
isNull();
1108 if (OnlyPerformTypeDiff(Context, FromType, ToType, FromArgTST, ToArgTST)) {
1109 Tree.SetTypeDiff(FromType, ToType, FromDefault, ToDefault);
1113 assert(FromArgTST && ToArgTST &&
1114 "Both template specializations need to be valid.");
1119 Tree.SetTemplateDiff(FromArgTST->getTemplateName().getAsTemplateDecl(),
1120 ToArgTST->getTemplateName().getAsTemplateDecl(),
1121 FromQual, ToQual, FromDefault, ToDefault);
1122 DiffTemplate(FromArgTST, ToArgTST);
1128 void DiffTemplateTemplates(
const TSTiterator &FromIter,
1129 const TSTiterator &ToIter) {
1132 Tree.SetTemplateTemplateDiff(FromDecl, ToDecl, FromIter.isEnd() && FromDecl,
1133 ToIter.isEnd() && ToDecl);
1134 Tree.SetSame(FromDecl && ToDecl &&
1135 FromDecl->getCanonicalDecl() == ToDecl->getCanonicalDecl());
1139 static void InitializeNonTypeDiffVariables(
ASTContext &Context,
1140 const TSTiterator &Iter,
1142 llvm::APSInt &
Value,
bool &HasInt,
1143 QualType &IntType,
bool &IsNullPtr,
1145 bool &NeedAddressOf) {
1146 if (!Iter.isEnd()) {
1147 switch (Iter->getKind()) {
1149 llvm_unreachable(
"unknown ArgumentKind");
1151 Value = Iter->getAsIntegral();
1153 IntType = Iter->getIntegralType();
1156 VD = Iter->getAsDecl();
1157 QualType ArgType = Iter->getParamTypeForDecl();
1161 NeedAddressOf =
true;
1168 E = Iter->getAsExpr();
1174 if (!Iter.hasDesugaredTA())
return;
1179 llvm_unreachable(
"unknown ArgumentKind");
1191 NeedAddressOf =
true;
1209 void DiffNonTypes(
const TSTiterator &FromIter,
const TSTiterator &ToIter,
1212 Expr *FromExpr =
nullptr, *ToExpr =
nullptr;
1213 llvm::APSInt FromInt, ToInt;
1215 ValueDecl *FromValueDecl =
nullptr, *ToValueDecl =
nullptr;
1216 bool HasFromInt =
false, HasToInt =
false, FromNullPtr =
false,
1217 ToNullPtr =
false, NeedFromAddressOf =
false, NeedToAddressOf =
false;
1218 InitializeNonTypeDiffVariables(
1219 Context, FromIter, FromDefaultNonTypeDecl, FromInt, HasFromInt,
1220 FromIntType, FromNullPtr, FromExpr, FromValueDecl, NeedFromAddressOf);
1221 InitializeNonTypeDiffVariables(Context, ToIter, ToDefaultNonTypeDecl, ToInt,
1222 HasToInt, ToIntType, ToNullPtr, ToExpr,
1223 ToValueDecl, NeedToAddressOf);
1225 bool FromDefault = FromIter.isEnd() &&
1226 (FromExpr || FromValueDecl || HasFromInt || FromNullPtr);
1227 bool ToDefault = ToIter.isEnd() &&
1228 (ToExpr || ToValueDecl || HasToInt || ToNullPtr);
1230 bool FromDeclaration = FromValueDecl || FromNullPtr;
1231 bool ToDeclaration = ToValueDecl || ToNullPtr;
1233 if (FromDeclaration && HasToInt) {
1234 Tree.SetFromDeclarationAndToIntegerDiff(
1235 FromValueDecl, NeedFromAddressOf, FromNullPtr, FromExpr, ToInt,
1236 HasToInt, ToIntType, ToExpr, FromDefault, ToDefault);
1237 Tree.SetSame(
false);
1242 if (HasFromInt && ToDeclaration) {
1243 Tree.SetFromIntegerAndToDeclarationDiff(
1244 FromInt, HasFromInt, FromIntType, FromExpr, ToValueDecl,
1245 NeedToAddressOf, ToNullPtr, ToExpr, FromDefault, ToDefault);
1246 Tree.SetSame(
false);
1250 if (HasFromInt || HasToInt) {
1251 Tree.SetIntegerDiff(FromInt, ToInt, HasFromInt, HasToInt, FromIntType,
1252 ToIntType, FromExpr, ToExpr, FromDefault, ToDefault);
1253 if (HasFromInt && HasToInt) {
1254 Tree.SetSame(Context.
hasSameType(FromIntType, ToIntType) &&
1260 if (FromDeclaration || ToDeclaration) {
1261 Tree.SetDeclarationDiff(FromValueDecl, ToValueDecl, NeedFromAddressOf,
1262 NeedToAddressOf, FromNullPtr, ToNullPtr, FromExpr,
1263 ToExpr, FromDefault, ToDefault);
1264 bool BothNull = FromNullPtr && ToNullPtr;
1265 bool SameValueDecl =
1266 FromValueDecl && ToValueDecl &&
1267 NeedFromAddressOf == NeedToAddressOf &&
1268 FromValueDecl->getCanonicalDecl() == ToValueDecl->getCanonicalDecl();
1269 Tree.SetSame(BothNull || SameValueDecl);
1273 assert((FromExpr || ToExpr) &&
"Both template arguments cannot be empty.");
1274 Tree.SetExpressionDiff(FromExpr, ToExpr, FromDefault, ToDefault);
1275 Tree.SetSame(IsEqualExpr(Context, FromExpr, ToExpr));
1284 FromTST->getTemplateName().getAsTemplateDecl()->getTemplateParameters();
1286 ToTST->getTemplateName().getAsTemplateDecl()->getTemplateParameters();
1287 unsigned TotalArgs = 0;
1288 for (TSTiterator FromIter(Context, FromTST), ToIter(Context, ToTST);
1289 !FromIter.isEnd() || !ToIter.isEnd(); ++TotalArgs) {
1295 unsigned FromParamIndex =
std::min(TotalArgs, ParamsFrom->
size() - 1);
1296 unsigned ToParamIndex =
std::min(TotalArgs, ParamsTo->
size() - 1);
1300 assert(FromParamND->getKind() == ToParamND->getKind() &&
1301 "Parameter Decl are not the same kind.");
1303 if (isa<TemplateTypeParmDecl>(FromParamND)) {
1304 DiffTypes(FromIter, ToIter);
1305 }
else if (isa<TemplateTemplateParmDecl>(FromParamND)) {
1306 DiffTemplateTemplates(FromIter, ToIter);
1307 }
else if (isa<NonTypeTemplateParmDecl>(FromParamND)) {
1309 cast<NonTypeTemplateParmDecl>(FromParamND);
1311 cast<NonTypeTemplateParmDecl>(ToParamND);
1312 DiffNonTypes(FromIter, ToIter, FromDefaultNonTypeDecl,
1313 ToDefaultNonTypeDecl);
1315 llvm_unreachable(
"Unexpected Decl type.");
1325 static void makeTemplateList(
1329 TemplateList.push_back(TST);
1330 if (!TST->isTypeAlias())
1340 return FromTST->getTemplateName().getAsTemplateDecl()->getCanonicalDecl() ==
1341 ToTST->getTemplateName().getAsTemplateDecl()->getCanonicalDecl();
1351 if (hasSameBaseTemplate(FromTST, ToTST))
1358 makeTemplateList(FromTemplateList, FromTST);
1359 makeTemplateList(ToTemplateList, ToTST);
1362 FromIter = FromTemplateList.rbegin(), FromEnd = FromTemplateList.rend(),
1363 ToIter = ToTemplateList.rbegin(), ToEnd = ToTemplateList.rend();
1366 if (!hasSameBaseTemplate(*FromIter, *ToIter))
1372 for (; FromIter != FromEnd && ToIter != ToEnd; ++FromIter, ++ToIter) {
1373 if (!hasSameBaseTemplate(*FromIter, *ToIter))
1377 FromTST = FromIter[-1];
1385 static QualType GetType(
const TSTiterator &Iter) {
1387 return Iter->getAsType();
1388 if (Iter.hasDesugaredTA())
1389 return Iter.getDesugaredTA().getAsType();
1395 static TemplateDecl *GetTemplateDecl(
const TSTiterator &Iter) {
1397 return Iter->getAsTemplate().getAsTemplateDecl();
1398 if (Iter.hasDesugaredTA())
1399 return Iter.getDesugaredTA().getAsTemplate().getAsTemplateDecl();
1407 if (FromExpr == ToExpr)
1410 if (!FromExpr || !ToExpr)
1413 llvm::FoldingSetNodeID FromID, ToID;
1414 FromExpr->Profile(FromID, Context,
true);
1415 ToExpr->Profile(ToID, Context,
true);
1416 return FromID == ToID;
1424 void TreeToString(
int Indent = 1) {
1433 switch (Tree.GetKind()) {
1434 case DiffTree::Invalid:
1435 llvm_unreachable(
"Template diffing failed with bad DiffNode");
1436 case DiffTree::Type: {
1438 Tree.GetTypeDiff(FromType, ToType);
1439 PrintTypeNames(FromType, ToType, Tree.FromDefault(), Tree.ToDefault(),
1443 case DiffTree::Expression: {
1444 Expr *FromExpr, *ToExpr;
1445 Tree.GetExpressionDiff(FromExpr, ToExpr);
1446 PrintExpr(FromExpr, ToExpr, Tree.FromDefault(), Tree.ToDefault(),
1450 case DiffTree::TemplateTemplate: {
1452 Tree.GetTemplateTemplateDiff(FromTD, ToTD);
1453 PrintTemplateTemplate(FromTD, ToTD, Tree.FromDefault(),
1454 Tree.ToDefault(), Tree.NodeIsSame());
1457 case DiffTree::Integer: {
1458 llvm::APSInt FromInt, ToInt;
1459 Expr *FromExpr, *ToExpr;
1460 bool IsValidFromInt, IsValidToInt;
1462 Tree.GetIntegerDiff(FromInt, ToInt, IsValidFromInt, IsValidToInt,
1463 FromIntType, ToIntType, FromExpr, ToExpr);
1464 PrintAPSInt(FromInt, ToInt, IsValidFromInt, IsValidToInt, FromIntType,
1465 ToIntType, FromExpr, ToExpr, Tree.FromDefault(),
1466 Tree.ToDefault(), Tree.NodeIsSame());
1469 case DiffTree::Declaration: {
1471 bool FromAddressOf, ToAddressOf;
1472 bool FromNullPtr, ToNullPtr;
1473 Expr *FromExpr, *ToExpr;
1474 Tree.GetDeclarationDiff(FromValueDecl, ToValueDecl, FromAddressOf,
1475 ToAddressOf, FromNullPtr, ToNullPtr, FromExpr,
1477 PrintValueDecl(FromValueDecl, ToValueDecl, FromAddressOf, ToAddressOf,
1478 FromNullPtr, ToNullPtr, FromExpr, ToExpr,
1479 Tree.FromDefault(), Tree.ToDefault(), Tree.NodeIsSame());
1482 case DiffTree::FromDeclarationAndToInteger: {
1491 Tree.GetFromDeclarationAndToIntegerDiff(
1492 FromValueDecl, FromAddressOf, FromNullPtr, FromExpr, ToInt,
1493 IsValidToInt, ToIntType, ToExpr);
1494 assert((FromValueDecl || FromNullPtr) && IsValidToInt);
1495 PrintValueDeclAndInteger(FromValueDecl, FromAddressOf, FromNullPtr,
1496 FromExpr, Tree.FromDefault(), ToInt, ToIntType,
1497 ToExpr, Tree.ToDefault());
1500 case DiffTree::FromIntegerAndToDeclaration: {
1501 llvm::APSInt FromInt;
1502 bool IsValidFromInt;
1509 Tree.GetFromIntegerAndToDeclarationDiff(
1510 FromInt, IsValidFromInt, FromIntType, FromExpr, ToValueDecl,
1511 ToAddressOf, ToNullPtr, ToExpr);
1512 assert(IsValidFromInt && (ToValueDecl || ToNullPtr));
1513 PrintIntegerAndValueDecl(FromInt, FromIntType, FromExpr,
1514 Tree.FromDefault(), ToValueDecl, ToAddressOf,
1515 ToNullPtr, ToExpr, Tree.ToDefault());
1518 case DiffTree::Template: {
1522 Tree.GetTemplateDiff(FromTD, ToTD, FromQual, ToQual);
1524 PrintQualifiers(FromQual, ToQual);
1526 if (!Tree.HasChildren()) {
1535 unsigned NumElideArgs = 0;
1536 bool AllArgsElided =
true;
1539 if (Tree.NodeIsSame()) {
1543 AllArgsElided =
false;
1544 if (NumElideArgs > 0) {
1545 PrintElideArgs(NumElideArgs,
Indent);
1551 if (Tree.HasNextSibling())
1553 }
while (Tree.AdvanceSibling());
1554 if (NumElideArgs > 0) {
1558 PrintElideArgs(NumElideArgs,
Indent);
1574 assert(!IsBold &&
"Attempting to bold text that is already bold.");
1582 assert(IsBold &&
"Attempting to remove bold from unbold text.");
1594 bool FromDefault,
bool ToDefault,
bool Same) {
1596 "Only one template argument may be missing.");
1608 PrintQualifiers(FromQual, ToQual);
1613 std::string FromTypeStr = FromType.
isNull() ?
"(no argument)"
1615 std::string ToTypeStr = ToType.
isNull() ?
"(no argument)"
1619 if (FromTypeStr == ToTypeStr) {
1620 std::string FromCanTypeStr =
1623 if (FromCanTypeStr != ToCanTypeStr) {
1624 FromTypeStr = FromCanTypeStr;
1625 ToTypeStr = ToCanTypeStr;
1629 if (PrintTree) OS <<
'[';
1630 OS << (FromDefault ?
"(default) " :
"");
1635 OS <<
" != " << (ToDefault ?
"(default) " :
"");
1645 void PrintExpr(
const Expr *FromExpr,
const Expr *ToExpr,
bool FromDefault,
1646 bool ToDefault,
bool Same) {
1647 assert((FromExpr || ToExpr) &&
1648 "Only one template argument may be missing.");
1650 PrintExpr(FromExpr);
1651 }
else if (!PrintTree) {
1652 OS << (FromDefault ?
"(default) " :
"");
1654 PrintExpr(FromExpr);
1657 OS << (FromDefault ?
"[(default) " :
"[");
1659 PrintExpr(FromExpr);
1661 OS <<
" != " << (ToDefault ?
"(default) " :
"");
1670 void PrintExpr(
const Expr *E) {
1672 E->printPretty(OS,
nullptr, Policy);
1675 OS <<
"(no argument)";
1681 bool FromDefault,
bool ToDefault,
bool Same) {
1682 assert((FromTD || ToTD) &&
"Only one template argument may be missing.");
1684 std::string FromName = FromTD ? FromTD->
getName() :
"(no argument)";
1685 std::string ToName = ToTD ? ToTD->
getName() :
"(no argument)";
1686 if (FromTD && ToTD && FromName == ToName) {
1693 }
else if (!PrintTree) {
1694 OS << (FromDefault ?
"(default) template " :
"template ");
1699 OS << (FromDefault ?
"[(default) template " :
"[template ");
1703 OS <<
" != " << (ToDefault ?
"(default) template " :
"template ");
1713 void PrintAPSInt(
const llvm::APSInt &FromInt,
const llvm::APSInt &ToInt,
1714 bool IsValidFromInt,
bool IsValidToInt,
QualType FromIntType,
1716 bool FromDefault,
bool ToDefault,
bool Same) {
1717 assert((IsValidFromInt || IsValidToInt) &&
1718 "Only one integral argument may be missing.");
1722 OS << ((FromInt == 0) ?
"false" :
"true");
1724 OS << FromInt.toString(10);
1729 bool PrintType = IsValidFromInt && IsValidToInt &&
1733 OS << (FromDefault ?
"(default) " :
"");
1734 PrintAPSInt(FromInt, FromExpr, IsValidFromInt, FromIntType, PrintType);
1736 OS << (FromDefault ?
"[(default) " :
"[");
1737 PrintAPSInt(FromInt, FromExpr, IsValidFromInt, FromIntType, PrintType);
1738 OS <<
" != " << (ToDefault ?
"(default) " :
"");
1739 PrintAPSInt(ToInt, ToExpr, IsValidToInt, ToIntType, PrintType);
1746 void PrintAPSInt(
const llvm::APSInt &Val,
Expr *E,
bool Valid,
1747 QualType IntType,
bool PrintType) {
1750 if (HasExtraInfo(E)) {
1766 OS << ((Val == 0) ?
"false" :
"true");
1768 OS << Val.toString(10);
1773 OS <<
"(no argument)";
1780 bool HasExtraInfo(
Expr *E) {
1781 if (!E)
return false;
1785 if (isa<IntegerLiteral>(E))
return false;
1788 if (UO->getOpcode() == UO_Minus)
1789 if (isa<IntegerLiteral>(UO->getSubExpr()))
1792 if (isa<CXXBoolLiteralExpr>(E))
1798 void PrintValueDecl(
ValueDecl *VD,
bool AddressOf,
Expr *E,
bool NullPtr) {
1807 if (E && !isa<CXXNullPtrLiteralExpr>(E)) {
1822 OS <<
"(no argument)";
1828 bool FromAddressOf,
bool ToAddressOf,
bool FromNullPtr,
1829 bool ToNullPtr,
Expr *FromExpr,
Expr *ToExpr,
1830 bool FromDefault,
bool ToDefault,
bool Same) {
1831 assert((FromValueDecl || FromNullPtr || ToValueDecl || ToNullPtr) &&
1832 "Only one Decl argument may be NULL");
1835 PrintValueDecl(FromValueDecl, FromAddressOf, FromExpr, FromNullPtr);
1836 }
else if (!PrintTree) {
1837 OS << (FromDefault ?
"(default) " :
"");
1839 PrintValueDecl(FromValueDecl, FromAddressOf, FromExpr, FromNullPtr);
1842 OS << (FromDefault ?
"[(default) " :
"[");
1844 PrintValueDecl(FromValueDecl, FromAddressOf, FromExpr, FromNullPtr);
1846 OS <<
" != " << (ToDefault ?
"(default) " :
"");
1848 PrintValueDecl(ToValueDecl, ToAddressOf, ToExpr, ToNullPtr);
1856 void PrintValueDeclAndInteger(
ValueDecl *VD,
bool NeedAddressOf,
1857 bool IsNullPtr,
Expr *VDExpr,
bool DefaultDecl,
1858 const llvm::APSInt &Val,
QualType IntType,
1859 Expr *IntExpr,
bool DefaultInt) {
1861 OS << (DefaultDecl ?
"(default) " :
"");
1863 PrintValueDecl(VD, NeedAddressOf, VDExpr, IsNullPtr);
1866 OS << (DefaultDecl ?
"[(default) " :
"[");
1868 PrintValueDecl(VD, NeedAddressOf, VDExpr, IsNullPtr);
1870 OS <<
" != " << (DefaultInt ?
"(default) " :
"");
1871 PrintAPSInt(Val, IntExpr,
true , IntType,
false );
1878 void PrintIntegerAndValueDecl(
const llvm::APSInt &Val,
QualType IntType,
1880 bool NeedAddressOf,
bool IsNullPtr,
1881 Expr *VDExpr,
bool DefaultDecl) {
1883 OS << (DefaultInt ?
"(default) " :
"");
1884 PrintAPSInt(Val, IntExpr,
true , IntType,
false );
1886 OS << (DefaultInt ?
"[(default) " :
"[");
1887 PrintAPSInt(Val, IntExpr,
true , IntType,
false );
1888 OS <<
" != " << (DefaultDecl ?
"(default) " :
"");
1890 PrintValueDecl(VD, NeedAddressOf, VDExpr, IsNullPtr);
1897 void PrintElideArgs(
unsigned NumElideArgs,
unsigned Indent) {
1900 for (
unsigned i = 0; i <
Indent; ++i)
1903 if (NumElideArgs == 0)
return;
1904 if (NumElideArgs == 1)
1907 OS <<
"[" << NumElideArgs <<
" * ...]";
1917 if (FromQual == ToQual) {
1918 PrintQualifier(FromQual,
false);
1938 if (CommonQual.
empty() && FromQual.
empty()) {
1940 OS <<
"(no qualifiers) ";
1943 PrintQualifier(CommonQual,
false);
1944 PrintQualifier(FromQual,
true);
1949 OS <<
"(no qualifiers)";
1952 PrintQualifier(CommonQual,
false,
1954 PrintQualifier(ToQual,
true,
1959 PrintQualifier(CommonQual,
false);
1960 PrintQualifier(FromQual,
true);
1964 void PrintQualifier(
Qualifiers Q,
bool ApplyBold,
1965 bool AppendSpaceIfNonEmpty =
true) {
1966 if (Q.
empty())
return;
1967 if (ApplyBold) Bold();
1968 Q.
print(OS, Policy, AppendSpaceIfNonEmpty);
1969 if (ApplyBold) Unbold();
1975 QualType ToType,
bool PrintTree,
bool PrintFromType,
1976 bool ElideType,
bool ShowColor)
1978 Policy(Context.getLangOpts()),
1979 ElideType(ElideType),
1980 PrintTree(PrintTree),
1981 ShowColor(ShowColor),
1983 FromTemplateType(PrintFromType ? FromType : ToType),
1984 ToTemplateType(PrintFromType ? ToType : FromType),
1990 void DiffTemplate() {
1991 Qualifiers FromQual = FromTemplateType.getQualifiers(),
1992 ToQual = ToTemplateType.getQualifiers();
1995 GetTemplateSpecializationType(Context, FromTemplateType);
1997 GetTemplateSpecializationType(Context, ToTemplateType);
2000 if (!FromOrigTST || !ToOrigTST)
2004 if (!hasSameTemplate(FromOrigTST, ToOrigTST)) {
2012 Tree.SetTemplateDiff(FromOrigTST->getTemplateName().getAsTemplateDecl(),
2013 ToOrigTST->getTemplateName().getAsTemplateDecl(),
2014 FromQual, ToQual,
false ,
2017 DiffTemplate(FromOrigTST, ToOrigTST);
2024 Tree.StartTraverse();
2029 assert(!IsBold &&
"Bold is applied to end of string.");
2040 bool PrintFromType,
bool ElideType,
2041 bool ShowColors, raw_ostream &OS) {
2043 PrintFromType =
true;
2044 TemplateDiff TD(OS, Context, FromType, ToType, PrintTree, PrintFromType,
2045 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...
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
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...
void print(raw_ostream &OS, const PrintingPolicy &Policy, const Twine &PlaceHolder=Twine(), unsigned Indentation=0) const
static Qualifiers removeCommonQualifiers(Qualifiers &L, Qualifiers &R)
Returns the common set of qualifiers while removing them from the given sets.
TypeClass getTypeClass() const
__INTPTR_TYPE__ intptr_t
A signed integer type with the property that any valid pointer to void can be converted to this type...
void print(raw_ostream &OS, const PrintingPolicy &Policy, bool appendSpaceIfNonEmpty=false) const
bool isLambdaCallOperator(const CXXMethodDecl *MD)
detail::InMemoryDirectory::const_iterator I
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.
bool isTypeAlias() const
Determine if this template specialization type is for a type alias template that has been substituted...
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
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)
char __ovld __cnfn min(char x, char y)
Returns y if y < x, otherwise it returns x.
static Optional< NullabilityKind > stripOuterNullability(QualType &T)
Strip off the top-level nullability annotation on the given type, if it's there.
QualType getObjCIdType() const
Represents the Objective-CC id type.
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.
QualType getTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args, QualType Canon=QualType()) const
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.
TemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args, QualType Canon, QualType Aliased)
Attr - This represents one attribute.
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
bool isPointerType() const