22 #include "llvm/ADT/StringExtras.h"
23 #include "llvm/Support/raw_ostream.h"
25 using namespace clang;
42 if (
const UsingType *UT = dyn_cast<UsingType>(Ty)) {
47 if (
const ParenType *PT = dyn_cast<ParenType>(Ty)) {
58 dyn_cast<SubstTemplateTypeParmType>(Ty)) {
68 if (
const AdjustedType *AT = dyn_cast<AdjustedType>(Ty)) {
73 if (
const AutoType *AT = dyn_cast<AutoType>(Ty)) {
82 if (
const FunctionType *FT = dyn_cast<FunctionType>(Ty)) {
83 bool DesugarReturn =
false;
84 QualType SugarRT = FT->getReturnType();
91 bool DesugarArgument =
false;
97 if (
auto nullability =
106 if (DesugarReturn || DesugarArgument) {
117 dyn_cast<TemplateSpecializationType>(Ty)) {
118 if (!TST->isTypeAlias()) {
119 bool DesugarArgument =
false;
121 for (
unsigned I = 0, N = TST->getNumArgs(); I != N; ++I) {
130 if (DesugarArgument) {
133 TST->getTemplateName(), Args, QT);
139 if (
const auto *AT = dyn_cast<ArrayType>(Ty)) {
142 if (
const auto *CAT = dyn_cast<ConstantArrayType>(AT))
144 ElementTy, CAT->getSize(), CAT->getSizeExpr(),
145 CAT->getSizeModifier(), CAT->getIndexTypeCVRQualifiers());
146 else if (
const auto *VAT = dyn_cast<VariableArrayType>(AT))
148 ElementTy, VAT->getSizeExpr(), VAT->getSizeModifier(),
149 VAT->getIndexTypeCVRQualifiers(), VAT->getBracketsRange());
150 else if (
const auto *DSAT = dyn_cast<DependentSizedArrayType>(AT))
152 ElementTy, DSAT->getSizeExpr(), DSAT->getSizeModifier(),
153 DSAT->getIndexTypeCVRQualifiers(), DSAT->getBracketsRange());
154 else if (
const auto *IAT = dyn_cast<IncompleteArrayType>(AT))
156 IAT->getIndexTypeCVRQualifiers());
158 llvm_unreachable(
"Unhandled array type");
176 bool IsSugar =
false;
178 #define ABSTRACT_TYPE(Class, Base)
179 #define TYPE(Class, Base) \
180 case Type::Class: { \
181 const Class##Type *CTy = cast<Class##Type>(Ty); \
182 if (CTy->isSugared()) { \
184 Underlying = CTy->desugar(); \
188 #include "clang/AST/TypeNodes.inc"
197 if (isa<VectorType>(Underlying))
202 if (
const TypedefType *QTT = dyn_cast<TypedefType>(QT))
203 if (UTT->getDecl()->getTypedefNameForAnonDecl() == QTT->getDecl())
226 if (Ty->getBaseType().getTypePtr() != Ty && !ShouldAKA) {
230 BaseType, Ty->getTypeArgsAsWritten(),
231 llvm::makeArrayRef(Ty->qual_begin(), Ty->getNumProtocols()),
232 Ty->isKindOfTypeAsWritten());
236 return QC.
apply(Context, QT);
268 bool ForceAKA =
false;
273 for (
const intptr_t &QualTypeVal : QualTypeVals) {
281 if (CompareCanTy == CanTy)
284 bool ShouldAKA =
false;
289 if (CompareS != S && CompareDesugarStr != S)
295 if (CompareCanS == CanS)
304 bool Repeated =
false;
305 for (
const auto &PrevArg : PrevArgs) {
320 bool ShouldAKA =
false;
322 if (ShouldAKA || ForceAKA) {
323 if (DesugaredTy == Ty) {
328 S =
"'" + S +
"' (aka '" + akaStr +
"')";
338 llvm::raw_string_ostream OS(DecoratedString);
339 const char *Values = VTy->getNumElements() > 1 ?
"values" :
"value";
340 OS <<
"'" << S <<
"' (vector of " << VTy->getNumElements() <<
" '"
342 <<
"' " << Values <<
")";
343 return DecoratedString;
353 bool PrintFromType,
bool ElideType,
354 bool ShowColors, raw_ostream &OS);
367 size_t OldEnd = Output.size();
368 llvm::raw_svector_ostream OS(Output);
369 bool NeedQuotes =
true;
372 default: llvm_unreachable(
"unknown ArgumentKind");
374 assert(Modifier.empty() && Argument.empty() &&
375 "Invalid modifier for Qualifiers argument");
379 OS << (Context.
getLangOpts().OpenCL ?
"default" :
"generic");
380 OS <<
" address space";
382 OS <<
"address space";
383 OS <<
" '" << S <<
"'";
389 assert(Modifier.empty() && Argument.empty() &&
390 "Invalid modifier for Qualifiers argument");
425 Modifier = StringRef();
426 Argument = StringRef();
431 assert(Modifier.empty() && Argument.empty() &&
432 "Invalid modifier for QualType argument");
440 if (Modifier ==
"objcclass" && Argument.empty())
442 else if (Modifier ==
"objcinstance" && Argument.empty())
445 assert(Modifier.empty() && Argument.empty() &&
446 "Invalid modifier for DeclarationName argument");
453 if (Modifier ==
"q" && Argument.empty())
456 assert(Modifier.empty() && Argument.empty() &&
457 "Invalid modifier for NamedDecl* argument");
472 assert(DC &&
"Should never have a null declaration context");
478 OS <<
"the global namespace";
480 OS <<
"the global scope";
482 OS <<
"block literal";
484 OS <<
"lambda expression";
488 PrevArgs, QualTypeVals);
490 assert(isa<NamedDecl>(DC) &&
"Expected a NamedDecl");
492 if (isa<NamespaceDecl>(ND))
494 else if (isa<ObjCMethodDecl>(ND))
496 else if (isa<FunctionDecl>(ND))
506 const Attr *At =
reinterpret_cast<Attr *
>(Val);
507 assert(At &&
"Received null Attr object!");
515 Output.insert(Output.begin()+OldEnd,
'\'');
516 Output.push_back(
'\'');
581 FromIntegerAndToDeclaration,
582 FromDeclarationAndToInteger
589 struct TemplateArgumentInfo {
593 bool IsValidInt =
false;
594 Expr *ArgExpr =
nullptr;
597 bool NeedAddressOf =
false;
598 bool IsNullPtr =
false;
599 bool IsDefault =
false;
609 unsigned NextNode = 0;
612 unsigned ChildNode = 0;
615 unsigned ParentNode = 0;
617 TemplateArgumentInfo FromArgInfo, ToArgInfo;
622 DiffNode(
unsigned ParentNode = 0) : ParentNode(ParentNode) {}
629 unsigned CurrentNode;
633 unsigned NextFreeNode;
639 DiffTree() : CurrentNode(0), NextFreeNode(1), ReadNode(0) {
640 FlatTree.push_back(DiffNode());
646 bool FromDefault,
bool ToDefault) {
647 assert(FlatTree[CurrentNode].
Kind == Invalid &&
"Node is not empty.");
648 FlatTree[CurrentNode].Kind = Template;
649 FlatTree[CurrentNode].FromArgInfo.TD = FromTD;
650 FlatTree[CurrentNode].ToArgInfo.TD = ToTD;
651 FlatTree[CurrentNode].FromArgInfo.Qual = FromQual;
652 FlatTree[CurrentNode].ToArgInfo.Qual = ToQual;
653 SetDefault(FromDefault, ToDefault);
658 assert(FlatTree[CurrentNode].
Kind == Invalid &&
"Node is not empty.");
659 FlatTree[CurrentNode].Kind =
Type;
660 FlatTree[CurrentNode].FromArgInfo.ArgType = FromType;
661 FlatTree[CurrentNode].ToArgInfo.ArgType = ToType;
662 SetDefault(FromDefault, ToDefault);
665 void SetExpressionDiff(
Expr *FromExpr,
Expr *ToExpr,
bool FromDefault,
667 assert(FlatTree[CurrentNode].
Kind == Invalid &&
"Node is not empty.");
669 FlatTree[CurrentNode].FromArgInfo.ArgExpr = FromExpr;
670 FlatTree[CurrentNode].ToArgInfo.ArgExpr = ToExpr;
671 SetDefault(FromDefault, ToDefault);
675 bool FromDefault,
bool ToDefault) {
676 assert(FlatTree[CurrentNode].
Kind == Invalid &&
"Node is not empty.");
677 FlatTree[CurrentNode].Kind = TemplateTemplate;
678 FlatTree[CurrentNode].FromArgInfo.TD = FromTD;
679 FlatTree[CurrentNode].ToArgInfo.TD = ToTD;
680 SetDefault(FromDefault, ToDefault);
684 bool IsValidFromInt,
bool IsValidToInt,
686 Expr *FromExpr,
Expr *ToExpr,
bool FromDefault,
688 assert(FlatTree[CurrentNode].
Kind == Invalid &&
"Node is not empty.");
689 FlatTree[CurrentNode].Kind =
Integer;
690 FlatTree[CurrentNode].FromArgInfo.Val = FromInt;
691 FlatTree[CurrentNode].ToArgInfo.Val = ToInt;
692 FlatTree[CurrentNode].FromArgInfo.IsValidInt = IsValidFromInt;
693 FlatTree[CurrentNode].ToArgInfo.IsValidInt = IsValidToInt;
694 FlatTree[CurrentNode].FromArgInfo.ArgType = FromIntType;
695 FlatTree[CurrentNode].ToArgInfo.ArgType = ToIntType;
696 FlatTree[CurrentNode].FromArgInfo.ArgExpr = FromExpr;
697 FlatTree[CurrentNode].ToArgInfo.ArgExpr = ToExpr;
698 SetDefault(FromDefault, ToDefault);
702 bool FromAddressOf,
bool ToAddressOf,
703 bool FromNullPtr,
bool ToNullPtr,
Expr *FromExpr,
704 Expr *ToExpr,
bool FromDefault,
bool ToDefault) {
705 assert(FlatTree[CurrentNode].
Kind == Invalid &&
"Node is not empty.");
707 FlatTree[CurrentNode].FromArgInfo.VD = FromValueDecl;
708 FlatTree[CurrentNode].ToArgInfo.VD = ToValueDecl;
709 FlatTree[CurrentNode].FromArgInfo.NeedAddressOf = FromAddressOf;
710 FlatTree[CurrentNode].ToArgInfo.NeedAddressOf = ToAddressOf;
711 FlatTree[CurrentNode].FromArgInfo.IsNullPtr = FromNullPtr;
712 FlatTree[CurrentNode].ToArgInfo.IsNullPtr = ToNullPtr;
713 FlatTree[CurrentNode].FromArgInfo.ArgExpr = FromExpr;
714 FlatTree[CurrentNode].ToArgInfo.ArgExpr = ToExpr;
715 SetDefault(FromDefault, ToDefault);
718 void SetFromDeclarationAndToIntegerDiff(
719 ValueDecl *FromValueDecl,
bool FromAddressOf,
bool FromNullPtr,
721 QualType ToIntType,
Expr *ToExpr,
bool FromDefault,
bool ToDefault) {
722 assert(FlatTree[CurrentNode].
Kind == Invalid &&
"Node is not empty.");
723 FlatTree[CurrentNode].Kind = FromDeclarationAndToInteger;
724 FlatTree[CurrentNode].FromArgInfo.VD = FromValueDecl;
725 FlatTree[CurrentNode].FromArgInfo.NeedAddressOf = FromAddressOf;
726 FlatTree[CurrentNode].FromArgInfo.IsNullPtr = FromNullPtr;
727 FlatTree[CurrentNode].FromArgInfo.ArgExpr = FromExpr;
728 FlatTree[CurrentNode].ToArgInfo.Val = ToInt;
729 FlatTree[CurrentNode].ToArgInfo.IsValidInt = IsValidToInt;
730 FlatTree[CurrentNode].ToArgInfo.ArgType = ToIntType;
731 FlatTree[CurrentNode].ToArgInfo.ArgExpr = ToExpr;
732 SetDefault(FromDefault, ToDefault);
735 void SetFromIntegerAndToDeclarationDiff(
738 bool ToNullPtr,
Expr *ToExpr,
bool FromDefault,
bool ToDefault) {
739 assert(FlatTree[CurrentNode].
Kind == Invalid &&
"Node is not empty.");
740 FlatTree[CurrentNode].Kind = FromIntegerAndToDeclaration;
741 FlatTree[CurrentNode].FromArgInfo.Val = FromInt;
742 FlatTree[CurrentNode].FromArgInfo.IsValidInt = IsValidFromInt;
743 FlatTree[CurrentNode].FromArgInfo.ArgType = FromIntType;
744 FlatTree[CurrentNode].FromArgInfo.ArgExpr = FromExpr;
745 FlatTree[CurrentNode].ToArgInfo.VD = ToValueDecl;
746 FlatTree[CurrentNode].ToArgInfo.NeedAddressOf = ToAddressOf;
747 FlatTree[CurrentNode].ToArgInfo.IsNullPtr = ToNullPtr;
748 FlatTree[CurrentNode].ToArgInfo.ArgExpr = ToExpr;
749 SetDefault(FromDefault, ToDefault);
753 void SetDefault(
bool FromDefault,
bool ToDefault) {
754 assert((!FromDefault || !ToDefault) &&
"Both arguments cannot be default.");
755 FlatTree[CurrentNode].FromArgInfo.IsDefault = FromDefault;
756 FlatTree[CurrentNode].ToArgInfo.IsDefault = ToDefault;
760 void SetSame(
bool Same) {
761 FlatTree[CurrentNode].Same = Same;
765 void SetKind(DiffKind
Kind) {
766 FlatTree[CurrentNode].Kind =
Kind;
771 assert(FlatTree[CurrentNode].
Kind != Invalid &&
772 "Cannot exit node before setting node information.");
773 CurrentNode = FlatTree[CurrentNode].ParentNode;
779 assert(FlatTree[CurrentNode].
Kind == Template &&
780 "Only Template nodes can have children nodes.");
781 FlatTree.push_back(DiffNode(CurrentNode));
782 DiffNode &
Node = FlatTree[CurrentNode];
783 if (
Node.ChildNode == 0) {
785 Node.ChildNode = NextFreeNode;
790 for (i =
Node.ChildNode; FlatTree[i].NextNode != 0;
791 i = FlatTree[i].NextNode) {
793 FlatTree[i].NextNode = NextFreeNode;
795 CurrentNode = NextFreeNode;
801 void StartTraverse() {
803 CurrentNode = NextFreeNode;
809 ReadNode = FlatTree[ReadNode].ParentNode;
814 assert(FlatTree[ReadNode].
Kind == Template &&
"Unexpected kind.");
815 FromTD = FlatTree[ReadNode].FromArgInfo.TD;
816 ToTD = FlatTree[ReadNode].ToArgInfo.TD;
817 FromQual = FlatTree[ReadNode].FromArgInfo.Qual;
818 ToQual = FlatTree[ReadNode].ToArgInfo.Qual;
822 assert(FlatTree[ReadNode].
Kind ==
Type &&
"Unexpected kind");
823 FromType = FlatTree[ReadNode].FromArgInfo.ArgType;
824 ToType = FlatTree[ReadNode].ToArgInfo.ArgType;
827 void GetExpressionDiff(
Expr *&FromExpr,
Expr *&ToExpr) {
828 assert(FlatTree[ReadNode].
Kind ==
Expression &&
"Unexpected kind");
829 FromExpr = FlatTree[ReadNode].FromArgInfo.ArgExpr;
830 ToExpr = FlatTree[ReadNode].ToArgInfo.ArgExpr;
834 assert(FlatTree[ReadNode].
Kind == TemplateTemplate &&
"Unexpected kind.");
835 FromTD = FlatTree[ReadNode].FromArgInfo.TD;
836 ToTD = FlatTree[ReadNode].ToArgInfo.TD;
840 bool &IsValidFromInt,
bool &IsValidToInt,
843 assert(FlatTree[ReadNode].
Kind == Integer &&
"Unexpected kind.");
844 FromInt = FlatTree[ReadNode].FromArgInfo.Val;
845 ToInt = FlatTree[ReadNode].ToArgInfo.Val;
846 IsValidFromInt = FlatTree[ReadNode].FromArgInfo.IsValidInt;
847 IsValidToInt = FlatTree[ReadNode].ToArgInfo.IsValidInt;
848 FromIntType = FlatTree[ReadNode].FromArgInfo.ArgType;
849 ToIntType = FlatTree[ReadNode].ToArgInfo.ArgType;
850 FromExpr = FlatTree[ReadNode].FromArgInfo.ArgExpr;
851 ToExpr = FlatTree[ReadNode].ToArgInfo.ArgExpr;
855 bool &FromAddressOf,
bool &ToAddressOf,
856 bool &FromNullPtr,
bool &ToNullPtr,
Expr *&FromExpr,
858 assert(FlatTree[ReadNode].
Kind == Declaration &&
"Unexpected kind.");
859 FromValueDecl = FlatTree[ReadNode].FromArgInfo.VD;
860 ToValueDecl = FlatTree[ReadNode].ToArgInfo.VD;
861 FromAddressOf = FlatTree[ReadNode].FromArgInfo.NeedAddressOf;
862 ToAddressOf = FlatTree[ReadNode].ToArgInfo.NeedAddressOf;
863 FromNullPtr = FlatTree[ReadNode].FromArgInfo.IsNullPtr;
864 ToNullPtr = FlatTree[ReadNode].ToArgInfo.IsNullPtr;
865 FromExpr = FlatTree[ReadNode].FromArgInfo.ArgExpr;
866 ToExpr = FlatTree[ReadNode].ToArgInfo.ArgExpr;
869 void GetFromDeclarationAndToIntegerDiff(
870 ValueDecl *&FromValueDecl,
bool &FromAddressOf,
bool &FromNullPtr,
873 assert(FlatTree[ReadNode].
Kind == FromDeclarationAndToInteger &&
875 FromValueDecl = FlatTree[ReadNode].FromArgInfo.VD;
876 FromAddressOf = FlatTree[ReadNode].FromArgInfo.NeedAddressOf;
877 FromNullPtr = FlatTree[ReadNode].FromArgInfo.IsNullPtr;
878 FromExpr = FlatTree[ReadNode].FromArgInfo.ArgExpr;
879 ToInt = FlatTree[ReadNode].ToArgInfo.Val;
880 IsValidToInt = FlatTree[ReadNode].ToArgInfo.IsValidInt;
881 ToIntType = FlatTree[ReadNode].ToArgInfo.ArgType;
882 ToExpr = FlatTree[ReadNode].ToArgInfo.ArgExpr;
885 void GetFromIntegerAndToDeclarationDiff(
888 bool &ToNullPtr,
Expr *&ToExpr) {
889 assert(FlatTree[ReadNode].
Kind == FromIntegerAndToDeclaration &&
891 FromInt = FlatTree[ReadNode].FromArgInfo.Val;
892 IsValidFromInt = FlatTree[ReadNode].FromArgInfo.IsValidInt;
893 FromIntType = FlatTree[ReadNode].FromArgInfo.ArgType;
894 FromExpr = FlatTree[ReadNode].FromArgInfo.ArgExpr;
895 ToValueDecl = FlatTree[ReadNode].ToArgInfo.VD;
896 ToAddressOf = FlatTree[ReadNode].ToArgInfo.NeedAddressOf;
897 ToNullPtr = FlatTree[ReadNode].ToArgInfo.IsNullPtr;
898 ToExpr = FlatTree[ReadNode].ToArgInfo.ArgExpr;
903 return FlatTree[ReadNode].FromArgInfo.IsDefault;
908 return FlatTree[ReadNode].ToArgInfo.IsDefault;
913 return FlatTree[ReadNode].Same;
918 return FlatTree[ReadNode].ChildNode != 0;
923 ReadNode = FlatTree[ReadNode].ChildNode;
928 bool AdvanceSibling() {
929 if (FlatTree[ReadNode].NextNode == 0)
932 ReadNode = FlatTree[ReadNode].NextNode;
937 bool HasNextSibling() {
938 return FlatTree[ReadNode].NextNode != 0;
948 return FlatTree[ReadNode].Kind;
965 struct InternalIterator {
983 : TST(TST), Index(0), CurrentTA(nullptr), EndTA(nullptr) {
997 if (CurrentTA != EndTA)
return;
1005 bool isValid()
const {
return TST; }
1008 bool isEnd()
const {
1009 assert(TST &&
"InternalIterator is invalid with a null TST.");
1014 InternalIterator &operator++() {
1015 assert(TST &&
"InternalIterator is invalid with a null TST.");
1021 if (CurrentTA != EndTA) {
1023 if (CurrentTA != EndTA)
1043 if (CurrentTA != EndTA)
1051 assert(TST &&
"InternalIterator is invalid with a null TST.");
1052 assert(!isEnd() &&
"Index exceeds number of arguments.");
1053 if (CurrentTA == EndTA)
1054 return TST->
getArg(Index);
1060 pointer operator->()
const {
1061 assert(TST &&
"InternalIterator is invalid with a null TST.");
1066 InternalIterator SugaredIterator;
1067 InternalIterator DesugaredIterator;
1071 : SugaredIterator(TST),
1073 (TST->isSugared() && !TST->isTypeAlias())
1074 ? GetTemplateSpecializationType(Context, TST->desugar())
1078 TSTiterator &operator++() {
1080 if (DesugaredIterator.isValid())
1081 ++DesugaredIterator;
1087 return *SugaredIterator;
1091 pointer operator->()
const {
1096 bool isEnd()
const {
1097 return SugaredIterator.isEnd();
1102 bool hasDesugaredTA()
const {
1103 return DesugaredIterator.isValid() && !DesugaredIterator.isEnd();
1107 reference getDesugaredTA()
const {
1108 assert(DesugaredIterator.isValid() &&
1109 "Desugared TemplateArgument should not be used.");
1110 return *DesugaredIterator;
1124 Ty = SubstType->getReplacementType();
1132 dyn_cast<ClassTemplateSpecializationDecl>(RT->
getDecl());
1156 FromArgTST = GetTemplateSpecializationType(Context, FromType);
1157 ToArgTST = GetTemplateSpecializationType(Context, ToType);
1159 if (!FromArgTST || !ToArgTST)
1162 if (!hasSameTemplate(FromArgTST, ToArgTST))
1169 void DiffTypes(
const TSTiterator &FromIter,
const TSTiterator &ToIter) {
1170 QualType FromType = GetType(FromIter);
1173 bool FromDefault = FromIter.isEnd() && !FromType.
isNull();
1174 bool ToDefault = ToIter.isEnd() && !ToType.
isNull();
1178 if (OnlyPerformTypeDiff(Context, FromType, ToType, FromArgTST, ToArgTST)) {
1179 Tree.SetTypeDiff(FromType, ToType, FromDefault, ToDefault);
1183 assert(FromArgTST && ToArgTST &&
1184 "Both template specializations need to be valid.");
1191 FromQual, ToQual, FromDefault, ToDefault);
1192 DiffTemplate(FromArgTST, ToArgTST);
1198 void DiffTemplateTemplates(
const TSTiterator &FromIter,
1199 const TSTiterator &ToIter) {
1203 ToIter.isEnd() && ToDecl);
1209 static void InitializeNonTypeDiffVariables(
ASTContext &Context,
1210 const TSTiterator &Iter,
1213 QualType &IntType,
bool &IsNullPtr,
1215 bool &NeedAddressOf) {
1216 if (!Iter.isEnd()) {
1217 switch (Iter->getKind()) {
1219 llvm_unreachable(
"unknown ArgumentKind");
1221 Value = Iter->getAsIntegral();
1223 IntType = Iter->getIntegralType();
1226 VD = Iter->getAsDecl();
1227 QualType ArgType = Iter->getParamTypeForDecl();
1231 NeedAddressOf =
true;
1238 E = Iter->getAsExpr();
1240 }
else if (!
Default->isParameterPack()) {
1241 E =
Default->getDefaultArgument();
1244 if (!Iter.hasDesugaredTA())
return;
1249 llvm_unreachable(
"unknown ArgumentKind");
1261 NeedAddressOf =
true;
1279 void DiffNonTypes(
const TSTiterator &FromIter,
const TSTiterator &ToIter,
1282 Expr *FromExpr =
nullptr, *ToExpr =
nullptr;
1285 ValueDecl *FromValueDecl =
nullptr, *ToValueDecl =
nullptr;
1286 bool HasFromInt =
false, HasToInt =
false, FromNullPtr =
false,
1287 ToNullPtr =
false, NeedFromAddressOf =
false, NeedToAddressOf =
false;
1288 InitializeNonTypeDiffVariables(
1289 Context, FromIter, FromDefaultNonTypeDecl, FromInt, HasFromInt,
1290 FromIntType, FromNullPtr, FromExpr, FromValueDecl, NeedFromAddressOf);
1291 InitializeNonTypeDiffVariables(Context, ToIter, ToDefaultNonTypeDecl, ToInt,
1292 HasToInt, ToIntType, ToNullPtr, ToExpr,
1293 ToValueDecl, NeedToAddressOf);
1295 bool FromDefault = FromIter.isEnd() &&
1296 (FromExpr || FromValueDecl || HasFromInt || FromNullPtr);
1297 bool ToDefault = ToIter.isEnd() &&
1298 (ToExpr || ToValueDecl || HasToInt || ToNullPtr);
1300 bool FromDeclaration = FromValueDecl || FromNullPtr;
1301 bool ToDeclaration = ToValueDecl || ToNullPtr;
1303 if (FromDeclaration && HasToInt) {
1304 Tree.SetFromDeclarationAndToIntegerDiff(
1305 FromValueDecl, NeedFromAddressOf, FromNullPtr, FromExpr, ToInt,
1306 HasToInt, ToIntType, ToExpr, FromDefault, ToDefault);
1307 Tree.SetSame(
false);
1312 if (HasFromInt && ToDeclaration) {
1313 Tree.SetFromIntegerAndToDeclarationDiff(
1314 FromInt, HasFromInt, FromIntType, FromExpr, ToValueDecl,
1315 NeedToAddressOf, ToNullPtr, ToExpr, FromDefault, ToDefault);
1316 Tree.SetSame(
false);
1320 if (HasFromInt || HasToInt) {
1321 Tree.SetIntegerDiff(FromInt, ToInt, HasFromInt, HasToInt, FromIntType,
1322 ToIntType, FromExpr, ToExpr, FromDefault, ToDefault);
1323 if (HasFromInt && HasToInt) {
1330 if (FromDeclaration || ToDeclaration) {
1331 Tree.SetDeclarationDiff(FromValueDecl, ToValueDecl, NeedFromAddressOf,
1332 NeedToAddressOf, FromNullPtr, ToNullPtr, FromExpr,
1333 ToExpr, FromDefault, ToDefault);
1334 bool BothNull = FromNullPtr && ToNullPtr;
1335 bool SameValueDecl =
1336 FromValueDecl && ToValueDecl &&
1337 NeedFromAddressOf == NeedToAddressOf &&
1339 Tree.SetSame(BothNull || SameValueDecl);
1343 assert((FromExpr || ToExpr) &&
"Both template arguments cannot be empty.");
1344 Tree.SetExpressionDiff(FromExpr, ToExpr, FromDefault, ToDefault);
1345 Tree.SetSame(IsEqualExpr(Context, FromExpr, ToExpr));
1357 unsigned TotalArgs = 0;
1358 for (TSTiterator FromIter(Context, FromTST), ToIter(Context, ToTST);
1359 !FromIter.isEnd() || !ToIter.isEnd(); ++TotalArgs) {
1365 unsigned FromParamIndex =
std::min(TotalArgs, ParamsFrom->
size() - 1);
1366 unsigned ToParamIndex =
std::min(TotalArgs, ParamsTo->
size() - 1);
1371 "Parameter Decl are not the same kind.");
1373 if (isa<TemplateTypeParmDecl>(FromParamND)) {
1374 DiffTypes(FromIter, ToIter);
1375 }
else if (isa<TemplateTemplateParmDecl>(FromParamND)) {
1376 DiffTemplateTemplates(FromIter, ToIter);
1377 }
else if (isa<NonTypeTemplateParmDecl>(FromParamND)) {
1379 cast<NonTypeTemplateParmDecl>(FromParamND);
1381 cast<NonTypeTemplateParmDecl>(ToParamND);
1382 DiffNonTypes(FromIter, ToIter, FromDefaultNonTypeDecl,
1383 ToDefaultNonTypeDecl);
1385 llvm_unreachable(
"Unexpected Decl type.");
1395 static void makeTemplateList(
1399 TemplateList.push_back(TST);
1421 if (hasSameBaseTemplate(FromTST, ToTST))
1428 makeTemplateList(FromTemplateList, FromTST);
1429 makeTemplateList(ToTemplateList, ToTST);
1432 FromIter = FromTemplateList.rbegin(), FromEnd = FromTemplateList.rend(),
1433 ToIter = ToTemplateList.rbegin(), ToEnd = ToTemplateList.rend();
1436 if (!hasSameBaseTemplate(*FromIter, *ToIter))
1442 for (; FromIter != FromEnd && ToIter != ToEnd; ++FromIter, ++ToIter) {
1443 if (!hasSameBaseTemplate(*FromIter, *ToIter))
1447 FromTST = FromIter[-1];
1455 static QualType GetType(
const TSTiterator &Iter) {
1457 return Iter->getAsType();
1458 if (Iter.hasDesugaredTA())
1459 return Iter.getDesugaredTA().getAsType();
1465 static TemplateDecl *GetTemplateDecl(
const TSTiterator &Iter) {
1467 return Iter->getAsTemplate().getAsTemplateDecl();
1468 if (Iter.hasDesugaredTA())
1469 return Iter.getDesugaredTA().getAsTemplate().getAsTemplateDecl();
1477 if (FromExpr == ToExpr)
1480 if (!FromExpr || !ToExpr)
1483 llvm::FoldingSetNodeID FromID, ToID;
1484 FromExpr->
Profile(FromID, Context,
true);
1485 ToExpr->
Profile(ToID, Context,
true);
1486 return FromID == ToID;
1494 void TreeToString(
int Indent = 1) {
1503 switch (
Tree.GetKind()) {
1505 llvm_unreachable(
"Template diffing failed with bad DiffNode");
1508 Tree.GetTypeDiff(FromType, ToType);
1509 PrintTypeNames(FromType, ToType,
Tree.FromDefault(),
Tree.ToDefault(),
1513 case DiffTree::Expression: {
1514 Expr *FromExpr, *ToExpr;
1515 Tree.GetExpressionDiff(FromExpr, ToExpr);
1516 PrintExpr(FromExpr, ToExpr,
Tree.FromDefault(),
Tree.ToDefault(),
1520 case DiffTree::TemplateTemplate: {
1522 Tree.GetTemplateTemplateDiff(FromTD, ToTD);
1523 PrintTemplateTemplate(FromTD, ToTD,
Tree.FromDefault(),
1524 Tree.ToDefault(),
Tree.NodeIsSame());
1527 case DiffTree::Integer: {
1529 Expr *FromExpr, *ToExpr;
1530 bool IsValidFromInt, IsValidToInt;
1532 Tree.GetIntegerDiff(FromInt, ToInt, IsValidFromInt, IsValidToInt,
1533 FromIntType, ToIntType, FromExpr, ToExpr);
1534 PrintAPSInt(FromInt, ToInt, IsValidFromInt, IsValidToInt, FromIntType,
1535 ToIntType, FromExpr, ToExpr,
Tree.FromDefault(),
1536 Tree.ToDefault(),
Tree.NodeIsSame());
1539 case DiffTree::Declaration: {
1541 bool FromAddressOf, ToAddressOf;
1542 bool FromNullPtr, ToNullPtr;
1543 Expr *FromExpr, *ToExpr;
1544 Tree.GetDeclarationDiff(FromValueDecl, ToValueDecl, FromAddressOf,
1545 ToAddressOf, FromNullPtr, ToNullPtr, FromExpr,
1547 PrintValueDecl(FromValueDecl, ToValueDecl, FromAddressOf, ToAddressOf,
1548 FromNullPtr, ToNullPtr, FromExpr, ToExpr,
1549 Tree.FromDefault(),
Tree.ToDefault(),
Tree.NodeIsSame());
1552 case DiffTree::FromDeclarationAndToInteger: {
1561 Tree.GetFromDeclarationAndToIntegerDiff(
1562 FromValueDecl, FromAddressOf, FromNullPtr, FromExpr, ToInt,
1563 IsValidToInt, ToIntType, ToExpr);
1564 assert((FromValueDecl || FromNullPtr) && IsValidToInt);
1565 PrintValueDeclAndInteger(FromValueDecl, FromAddressOf, FromNullPtr,
1566 FromExpr,
Tree.FromDefault(), ToInt, ToIntType,
1567 ToExpr,
Tree.ToDefault());
1570 case DiffTree::FromIntegerAndToDeclaration: {
1572 bool IsValidFromInt;
1579 Tree.GetFromIntegerAndToDeclarationDiff(
1580 FromInt, IsValidFromInt, FromIntType, FromExpr, ToValueDecl,
1581 ToAddressOf, ToNullPtr, ToExpr);
1582 assert(IsValidFromInt && (ToValueDecl || ToNullPtr));
1583 PrintIntegerAndValueDecl(FromInt, FromIntType, FromExpr,
1584 Tree.FromDefault(), ToValueDecl, ToAddressOf,
1585 ToNullPtr, ToExpr,
Tree.ToDefault());
1588 case DiffTree::Template: {
1592 Tree.GetTemplateDiff(FromTD, ToTD, FromQual, ToQual);
1594 PrintQualifiers(FromQual, ToQual);
1596 if (!
Tree.HasChildren()) {
1605 unsigned NumElideArgs = 0;
1606 bool AllArgsElided =
true;
1609 if (
Tree.NodeIsSame()) {
1613 AllArgsElided =
false;
1614 if (NumElideArgs > 0) {
1615 PrintElideArgs(NumElideArgs,
Indent);
1621 if (
Tree.HasNextSibling())
1623 }
while (
Tree.AdvanceSibling());
1624 if (NumElideArgs > 0) {
1628 PrintElideArgs(NumElideArgs,
Indent);
1644 assert(!IsBold &&
"Attempting to bold text that is already bold.");
1652 assert(IsBold &&
"Attempting to remove bold from unbold text.");
1664 bool FromDefault,
bool ToDefault,
bool Same) {
1666 "Only one template argument may be missing.");
1678 PrintQualifiers(FromQual, ToQual);
1689 if (FromTypeStr == ToTypeStr) {
1693 if (FromCanTypeStr != ToCanTypeStr) {
1694 FromTypeStr = FromCanTypeStr;
1695 ToTypeStr = ToCanTypeStr;
1699 if (PrintTree)
OS <<
'[';
1700 OS << (FromDefault ?
"(default) " :
"");
1705 OS <<
" != " << (ToDefault ?
"(default) " :
"");
1715 void PrintExpr(
const Expr *FromExpr,
const Expr *ToExpr,
bool FromDefault,
1716 bool ToDefault,
bool Same) {
1717 assert((FromExpr || ToExpr) &&
1718 "Only one template argument may be missing.");
1720 PrintExpr(FromExpr);
1721 }
else if (!PrintTree) {
1722 OS << (FromDefault ?
"(default) " :
"");
1724 PrintExpr(FromExpr);
1727 OS << (FromDefault ?
"[(default) " :
"[");
1729 PrintExpr(FromExpr);
1731 OS <<
" != " << (ToDefault ?
"(default) " :
"");
1740 void PrintExpr(
const Expr *E) {
1745 OS <<
"(no argument)";
1751 bool FromDefault,
bool ToDefault,
bool Same) {
1752 assert((FromTD || ToTD) &&
"Only one template argument may be missing.");
1757 if (FromTD && ToTD && FromName == ToName) {
1764 }
else if (!PrintTree) {
1765 OS << (FromDefault ?
"(default) template " :
"template ");
1770 OS << (FromDefault ?
"[(default) template " :
"[template ");
1774 OS <<
" != " << (ToDefault ?
"(default) template " :
"template ");
1785 bool IsValidFromInt,
bool IsValidToInt,
QualType FromIntType,
1787 bool FromDefault,
bool ToDefault,
bool Same) {
1788 assert((IsValidFromInt || IsValidToInt) &&
1789 "Only one integral argument may be missing.");
1793 OS << ((FromInt == 0) ?
"false" :
"true");
1800 bool PrintType = IsValidFromInt && IsValidToInt &&
1804 OS << (FromDefault ?
"(default) " :
"");
1805 PrintAPSInt(FromInt, FromExpr, IsValidFromInt, FromIntType, PrintType);
1807 OS << (FromDefault ?
"[(default) " :
"[");
1808 PrintAPSInt(FromInt, FromExpr, IsValidFromInt, FromIntType, PrintType);
1809 OS <<
" != " << (ToDefault ?
"(default) " :
"");
1810 PrintAPSInt(ToInt, ToExpr, IsValidToInt, ToIntType, PrintType);
1818 QualType IntType,
bool PrintType) {
1821 if (HasExtraInfo(E)) {
1837 OS << ((Val == 0) ?
"false" :
"true");
1844 OS <<
"(no argument)";
1851 bool HasExtraInfo(
Expr *E) {
1852 if (!E)
return false;
1856 if (isa<IntegerLiteral>(E))
return false;
1859 if (UO->getOpcode() == UO_Minus)
1860 if (isa<IntegerLiteral>(UO->getSubExpr()))
1863 if (isa<CXXBoolLiteralExpr>(E))
1869 void PrintValueDecl(
ValueDecl *VD,
bool AddressOf,
Expr *E,
bool NullPtr) {
1873 else if (
auto *TPO = dyn_cast<TemplateParamObjectDecl>(VD)) {
1877 TPO->printAsInit(OS, Policy);
1885 if (E && !isa<CXXNullPtrLiteralExpr>(E)) {
1900 OS <<
"(no argument)";
1906 bool FromAddressOf,
bool ToAddressOf,
bool FromNullPtr,
1907 bool ToNullPtr,
Expr *FromExpr,
Expr *ToExpr,
1908 bool FromDefault,
bool ToDefault,
bool Same) {
1909 assert((FromValueDecl || FromNullPtr || ToValueDecl || ToNullPtr) &&
1910 "Only one Decl argument may be NULL");
1913 PrintValueDecl(FromValueDecl, FromAddressOf, FromExpr, FromNullPtr);
1914 }
else if (!PrintTree) {
1915 OS << (FromDefault ?
"(default) " :
"");
1917 PrintValueDecl(FromValueDecl, FromAddressOf, FromExpr, FromNullPtr);
1920 OS << (FromDefault ?
"[(default) " :
"[");
1922 PrintValueDecl(FromValueDecl, FromAddressOf, FromExpr, FromNullPtr);
1924 OS <<
" != " << (ToDefault ?
"(default) " :
"");
1926 PrintValueDecl(ToValueDecl, ToAddressOf, ToExpr, ToNullPtr);
1934 void PrintValueDeclAndInteger(
ValueDecl *VD,
bool NeedAddressOf,
1935 bool IsNullPtr,
Expr *VDExpr,
bool DefaultDecl,
1937 Expr *IntExpr,
bool DefaultInt) {
1939 OS << (DefaultDecl ?
"(default) " :
"");
1941 PrintValueDecl(VD, NeedAddressOf, VDExpr, IsNullPtr);
1944 OS << (DefaultDecl ?
"[(default) " :
"[");
1946 PrintValueDecl(VD, NeedAddressOf, VDExpr, IsNullPtr);
1948 OS <<
" != " << (DefaultInt ?
"(default) " :
"");
1949 PrintAPSInt(Val, IntExpr,
true , IntType,
false );
1958 bool NeedAddressOf,
bool IsNullPtr,
1959 Expr *VDExpr,
bool DefaultDecl) {
1961 OS << (DefaultInt ?
"(default) " :
"");
1962 PrintAPSInt(Val, IntExpr,
true , IntType,
false );
1964 OS << (DefaultInt ?
"[(default) " :
"[");
1965 PrintAPSInt(Val, IntExpr,
true , IntType,
false );
1966 OS <<
" != " << (DefaultDecl ?
"(default) " :
"");
1968 PrintValueDecl(VD, NeedAddressOf, VDExpr, IsNullPtr);
1975 void PrintElideArgs(
unsigned NumElideArgs,
unsigned Indent) {
1978 for (
unsigned i = 0; i <
Indent; ++i)
1981 if (NumElideArgs == 0)
return;
1982 if (NumElideArgs == 1)
1985 OS <<
"[" << NumElideArgs <<
" * ...]";
1995 if (FromQual == ToQual) {
1996 PrintQualifier(FromQual,
false);
2016 if (CommonQual.
empty() && FromQual.
empty()) {
2018 OS <<
"(no qualifiers) ";
2021 PrintQualifier(CommonQual,
false);
2022 PrintQualifier(FromQual,
true);
2027 OS <<
"(no qualifiers)";
2030 PrintQualifier(CommonQual,
false,
2032 PrintQualifier(ToQual,
true,
2037 PrintQualifier(CommonQual,
false);
2038 PrintQualifier(FromQual,
true);
2042 void PrintQualifier(
Qualifiers Q,
bool ApplyBold,
2043 bool AppendSpaceIfNonEmpty =
true) {
2044 if (Q.
empty())
return;
2045 if (ApplyBold) Bold();
2046 Q.
print(OS, Policy, AppendSpaceIfNonEmpty);
2047 if (ApplyBold) Unbold();
2053 QualType ToType,
bool PrintTree,
bool PrintFromType,
2054 bool ElideType,
bool ShowColor)
2056 Policy(Context.getLangOpts()),
2057 ElideType(ElideType),
2058 PrintTree(PrintTree),
2059 ShowColor(ShowColor),
2061 FromTemplateType(PrintFromType ? FromType : ToType),
2062 ToTemplateType(PrintFromType ? ToType : FromType),
2068 void DiffTemplate() {
2073 GetTemplateSpecializationType(Context, FromTemplateType);
2075 GetTemplateSpecializationType(Context, ToTemplateType);
2078 if (!FromOrigTST || !ToOrigTST)
2082 if (!hasSameTemplate(FromOrigTST, ToOrigTST)) {
2092 FromQual, ToQual,
false ,
2095 DiffTemplate(FromOrigTST, ToOrigTST);
2102 Tree.StartTraverse();
2107 assert(!IsBold &&
"Bold is applied to end of string.");
2118 bool PrintFromType,
bool ElideType,
2119 bool ShowColors, raw_ostream &OS) {
2121 PrintFromType =
true;
2122 TemplateDiff TD(OS, Context, FromType, ToType, PrintTree, PrintFromType,
2123 ElideType, ShowColors);