22 #include "llvm/Support/raw_ostream.h" 24 using namespace clang;
40 if (
const ParenType *PT = dyn_cast<ParenType>(Ty)) {
51 dyn_cast<SubstTemplateTypeParmType>(Ty)) {
61 if (
const AdjustedType *AT = dyn_cast<AdjustedType>(Ty)) {
66 if (
const AutoType *AT = dyn_cast<AutoType>(Ty)) {
75 if (
const FunctionType *FT = dyn_cast<FunctionType>(Ty)) {
76 bool DesugarReturn =
false;
77 QualType SugarRT = FT->getReturnType();
84 bool DesugarArgument =
false;
90 if (
auto nullability =
99 if (DesugarReturn || DesugarArgument) {
110 dyn_cast<TemplateSpecializationType>(Ty)) {
111 if (!TST->isTypeAlias()) {
112 bool DesugarArgument =
false;
114 for (
unsigned I = 0, N = TST->getNumArgs(); I != N; ++I) {
122 if (DesugarArgument) {
125 TST->getTemplateName(), Args, QT);
145 bool IsSugar =
false;
147 #define ABSTRACT_TYPE(Class, Base) 148 #define TYPE(Class, Base) \ 149 case Type::Class: { \ 150 const Class##Type *CTy = cast<Class##Type>(Ty); \ 151 if (CTy->isSugared()) { \ 153 Underlying = CTy->desugar(); \ 157 #include "clang/AST/TypeNodes.inc" 166 if (isa<VectorType>(Underlying))
171 if (
const TypedefType *QTT = dyn_cast<TypedefType>(QT))
172 if (UTT->getDecl()->getTypedefNameForAnonDecl() == QTT->getDecl())
195 if (Ty->getBaseType().getTypePtr() != Ty && !ShouldAKA) {
198 llvm::makeArrayRef(Ty->qual_begin(),
199 Ty->getNumProtocols()),
200 Ty->isKindOfTypeAsWritten());
204 return QC.
apply(Context, QT);
236 bool ForceAKA =
false;
241 for (
unsigned I = 0, E = QualTypeVals.size(); I != E; ++I) {
249 if (CompareCanTy == CanTy)
252 bool ShouldAKA =
false;
254 std::string CompareDesugarStr =
256 if (CompareS != S && CompareDesugarStr != S)
259 std::string CompareCanS =
262 if (CompareCanS == CanS)
271 bool Repeated =
false;
272 for (
unsigned i = 0, e = PrevArgs.size(); i != e; ++i) {
275 void *Ptr = (
void*)PrevArgs[i].second;
287 bool ShouldAKA =
false;
289 if (ShouldAKA || ForceAKA) {
290 if (DesugaredTy == Ty) {
295 S =
"'" + S +
"' (aka '" + akaStr +
"')";
304 std::string DecoratedString;
305 llvm::raw_string_ostream OS(DecoratedString);
306 const char *Values = VTy->getNumElements() > 1 ?
"values" :
"value";
307 OS <<
"'" << S <<
"' (vector of " << VTy->getNumElements() <<
" '" 309 <<
"' " << Values <<
")";
320 bool PrintFromType,
bool ElideType,
321 bool ShowColors, raw_ostream &OS);
334 size_t OldEnd = Output.size();
335 llvm::raw_svector_ostream OS(Output);
336 bool NeedQuotes =
true;
339 default: llvm_unreachable(
"unknown ArgumentKind");
341 assert(Modifier.empty() && Argument.empty() &&
342 "Invalid modifier for Qualfiers argument");
346 OS << (Context.
getLangOpts().OpenCL ?
"default" :
"generic");
347 OS <<
" address space";
349 OS <<
"address space";
350 OS <<
" '" << S <<
"'";
356 assert(Modifier.empty() && Argument.empty() &&
357 "Invalid modifier for Qualfiers argument");
360 auto S = Q.getAsString();
392 Modifier = StringRef();
393 Argument = StringRef();
398 assert(Modifier.empty() && Argument.empty() &&
399 "Invalid modifier for QualType argument");
407 if (Modifier ==
"objcclass" && Argument.empty())
409 else if (Modifier ==
"objcinstance" && Argument.empty())
412 assert(Modifier.empty() && Argument.empty() &&
413 "Invalid modifier for DeclarationName argument");
420 if (Modifier ==
"q" && Argument.empty())
423 assert(Modifier.empty() && Argument.empty() &&
424 "Invalid modifier for NamedDecl* argument");
439 assert(DC &&
"Should never have a null declaration context");
445 OS <<
"the global namespace";
447 OS <<
"the global scope";
449 OS <<
"block literal";
451 OS <<
"lambda expression";
455 PrevArgs, QualTypeVals);
457 assert(isa<NamedDecl>(DC) &&
"Expected a NamedDecl");
459 if (isa<NamespaceDecl>(ND))
461 else if (isa<ObjCMethodDecl>(ND))
463 else if (isa<FunctionDecl>(ND))
473 const Attr *At =
reinterpret_cast<Attr *
>(Val);
474 assert(At &&
"Received null Attr object!");
482 Output.insert(Output.begin()+OldEnd,
'\'');
483 Output.push_back(
'\'');
548 FromIntegerAndToDeclaration,
549 FromDeclarationAndToInteger
556 struct TemplateArgumentInfo {
560 bool IsValidInt =
false;
561 Expr *ArgExpr =
nullptr;
564 bool NeedAddressOf =
false;
565 bool IsNullPtr =
false;
566 bool IsDefault =
false;
573 DiffKind
Kind = Invalid;
576 unsigned NextNode = 0;
579 unsigned ChildNode = 0;
582 unsigned ParentNode = 0;
584 TemplateArgumentInfo FromArgInfo, ToArgInfo;
589 DiffNode(
unsigned ParentNode = 0) : ParentNode(ParentNode) {}
596 unsigned CurrentNode;
600 unsigned NextFreeNode;
606 DiffTree() : CurrentNode(0), NextFreeNode(1), ReadNode(0) {
607 FlatTree.push_back(DiffNode());
613 bool FromDefault,
bool ToDefault) {
614 assert(FlatTree[CurrentNode].
Kind == Invalid &&
"Node is not empty.");
615 FlatTree[CurrentNode].Kind = Template;
616 FlatTree[CurrentNode].FromArgInfo.TD = FromTD;
617 FlatTree[CurrentNode].ToArgInfo.TD = ToTD;
618 FlatTree[CurrentNode].FromArgInfo.Qual = FromQual;
619 FlatTree[CurrentNode].ToArgInfo.Qual = ToQual;
620 SetDefault(FromDefault, ToDefault);
625 assert(FlatTree[CurrentNode].
Kind == Invalid &&
"Node is not empty.");
626 FlatTree[CurrentNode].Kind =
Type;
627 FlatTree[CurrentNode].FromArgInfo.ArgType = FromType;
628 FlatTree[CurrentNode].ToArgInfo.ArgType = ToType;
629 SetDefault(FromDefault, ToDefault);
632 void SetExpressionDiff(
Expr *FromExpr,
Expr *ToExpr,
bool FromDefault,
634 assert(FlatTree[CurrentNode].
Kind == Invalid &&
"Node is not empty.");
635 FlatTree[CurrentNode].Kind = Expression;
636 FlatTree[CurrentNode].FromArgInfo.ArgExpr = FromExpr;
637 FlatTree[CurrentNode].ToArgInfo.ArgExpr = ToExpr;
638 SetDefault(FromDefault, ToDefault);
642 bool FromDefault,
bool ToDefault) {
643 assert(FlatTree[CurrentNode].
Kind == Invalid &&
"Node is not empty.");
644 FlatTree[CurrentNode].Kind = TemplateTemplate;
645 FlatTree[CurrentNode].FromArgInfo.TD = FromTD;
646 FlatTree[CurrentNode].ToArgInfo.TD = ToTD;
647 SetDefault(FromDefault, ToDefault);
651 bool IsValidFromInt,
bool IsValidToInt,
653 Expr *FromExpr,
Expr *ToExpr,
bool FromDefault,
655 assert(FlatTree[CurrentNode].
Kind == Invalid &&
"Node is not empty.");
656 FlatTree[CurrentNode].Kind =
Integer;
657 FlatTree[CurrentNode].FromArgInfo.Val = FromInt;
658 FlatTree[CurrentNode].ToArgInfo.Val = ToInt;
659 FlatTree[CurrentNode].FromArgInfo.IsValidInt = IsValidFromInt;
660 FlatTree[CurrentNode].ToArgInfo.IsValidInt = IsValidToInt;
661 FlatTree[CurrentNode].FromArgInfo.ArgType = FromIntType;
662 FlatTree[CurrentNode].ToArgInfo.ArgType = ToIntType;
663 FlatTree[CurrentNode].FromArgInfo.ArgExpr = FromExpr;
664 FlatTree[CurrentNode].ToArgInfo.ArgExpr = ToExpr;
665 SetDefault(FromDefault, ToDefault);
669 bool FromAddressOf,
bool ToAddressOf,
670 bool FromNullPtr,
bool ToNullPtr,
Expr *FromExpr,
671 Expr *ToExpr,
bool FromDefault,
bool ToDefault) {
672 assert(FlatTree[CurrentNode].
Kind == Invalid &&
"Node is not empty.");
673 FlatTree[CurrentNode].Kind = Declaration;
674 FlatTree[CurrentNode].FromArgInfo.VD = FromValueDecl;
675 FlatTree[CurrentNode].ToArgInfo.VD = ToValueDecl;
676 FlatTree[CurrentNode].FromArgInfo.NeedAddressOf = FromAddressOf;
677 FlatTree[CurrentNode].ToArgInfo.NeedAddressOf = ToAddressOf;
678 FlatTree[CurrentNode].FromArgInfo.IsNullPtr = FromNullPtr;
679 FlatTree[CurrentNode].ToArgInfo.IsNullPtr = ToNullPtr;
680 FlatTree[CurrentNode].FromArgInfo.ArgExpr = FromExpr;
681 FlatTree[CurrentNode].ToArgInfo.ArgExpr = ToExpr;
682 SetDefault(FromDefault, ToDefault);
685 void SetFromDeclarationAndToIntegerDiff(
686 ValueDecl *FromValueDecl,
bool FromAddressOf,
bool FromNullPtr,
688 QualType ToIntType,
Expr *ToExpr,
bool FromDefault,
bool ToDefault) {
689 assert(FlatTree[CurrentNode].
Kind == Invalid &&
"Node is not empty.");
690 FlatTree[CurrentNode].Kind = FromDeclarationAndToInteger;
691 FlatTree[CurrentNode].FromArgInfo.VD = FromValueDecl;
692 FlatTree[CurrentNode].FromArgInfo.NeedAddressOf = FromAddressOf;
693 FlatTree[CurrentNode].FromArgInfo.IsNullPtr = FromNullPtr;
694 FlatTree[CurrentNode].FromArgInfo.ArgExpr = FromExpr;
695 FlatTree[CurrentNode].ToArgInfo.Val = ToInt;
696 FlatTree[CurrentNode].ToArgInfo.IsValidInt = IsValidToInt;
697 FlatTree[CurrentNode].ToArgInfo.ArgType = ToIntType;
698 FlatTree[CurrentNode].ToArgInfo.ArgExpr = ToExpr;
699 SetDefault(FromDefault, ToDefault);
702 void SetFromIntegerAndToDeclarationDiff(
705 bool ToNullPtr,
Expr *ToExpr,
bool FromDefault,
bool ToDefault) {
706 assert(FlatTree[CurrentNode].
Kind == Invalid &&
"Node is not empty.");
707 FlatTree[CurrentNode].Kind = FromIntegerAndToDeclaration;
708 FlatTree[CurrentNode].FromArgInfo.Val = FromInt;
709 FlatTree[CurrentNode].FromArgInfo.IsValidInt = IsValidFromInt;
710 FlatTree[CurrentNode].FromArgInfo.ArgType = FromIntType;
711 FlatTree[CurrentNode].FromArgInfo.ArgExpr = FromExpr;
712 FlatTree[CurrentNode].ToArgInfo.VD = ToValueDecl;
713 FlatTree[CurrentNode].ToArgInfo.NeedAddressOf = ToAddressOf;
714 FlatTree[CurrentNode].ToArgInfo.IsNullPtr = ToNullPtr;
715 FlatTree[CurrentNode].ToArgInfo.ArgExpr = ToExpr;
716 SetDefault(FromDefault, ToDefault);
720 void SetDefault(
bool FromDefault,
bool ToDefault) {
721 assert((!FromDefault || !ToDefault) &&
"Both arguments cannot be default.");
722 FlatTree[CurrentNode].FromArgInfo.IsDefault = FromDefault;
723 FlatTree[CurrentNode].ToArgInfo.IsDefault = ToDefault;
727 void SetSame(
bool Same) {
728 FlatTree[CurrentNode].Same = Same;
732 void SetKind(DiffKind
Kind) {
733 FlatTree[CurrentNode].Kind =
Kind;
738 assert(FlatTree[CurrentNode].Kind != Invalid &&
739 "Cannot exit node before setting node information.");
740 CurrentNode = FlatTree[CurrentNode].ParentNode;
746 assert(FlatTree[CurrentNode].Kind == Template &&
747 "Only Template nodes can have children nodes.");
748 FlatTree.push_back(DiffNode(CurrentNode));
749 DiffNode &
Node = FlatTree[CurrentNode];
750 if (Node.ChildNode == 0) {
752 Node.ChildNode = NextFreeNode;
757 for (i = Node.ChildNode; FlatTree[i].NextNode != 0;
758 i = FlatTree[i].NextNode) {
760 FlatTree[i].NextNode = NextFreeNode;
762 CurrentNode = NextFreeNode;
768 void StartTraverse() {
770 CurrentNode = NextFreeNode;
776 ReadNode = FlatTree[ReadNode].ParentNode;
781 assert(FlatTree[ReadNode].Kind == Template &&
"Unexpected kind.");
782 FromTD = FlatTree[ReadNode].FromArgInfo.TD;
783 ToTD = FlatTree[ReadNode].ToArgInfo.TD;
784 FromQual = FlatTree[ReadNode].FromArgInfo.Qual;
785 ToQual = FlatTree[ReadNode].ToArgInfo.Qual;
789 assert(FlatTree[ReadNode].Kind ==
Type &&
"Unexpected kind");
790 FromType = FlatTree[ReadNode].FromArgInfo.ArgType;
791 ToType = FlatTree[ReadNode].ToArgInfo.ArgType;
794 void GetExpressionDiff(
Expr *&FromExpr,
Expr *&ToExpr) {
795 assert(FlatTree[ReadNode].Kind == Expression &&
"Unexpected kind");
796 FromExpr = FlatTree[ReadNode].FromArgInfo.ArgExpr;
797 ToExpr = FlatTree[ReadNode].ToArgInfo.ArgExpr;
801 assert(FlatTree[ReadNode].Kind == TemplateTemplate &&
"Unexpected kind.");
802 FromTD = FlatTree[ReadNode].FromArgInfo.TD;
803 ToTD = FlatTree[ReadNode].ToArgInfo.TD;
807 bool &IsValidFromInt,
bool &IsValidToInt,
810 assert(FlatTree[ReadNode].Kind ==
Integer &&
"Unexpected kind.");
811 FromInt = FlatTree[ReadNode].FromArgInfo.Val;
812 ToInt = FlatTree[ReadNode].ToArgInfo.Val;
813 IsValidFromInt = FlatTree[ReadNode].FromArgInfo.IsValidInt;
814 IsValidToInt = FlatTree[ReadNode].ToArgInfo.IsValidInt;
815 FromIntType = FlatTree[ReadNode].FromArgInfo.ArgType;
816 ToIntType = FlatTree[ReadNode].ToArgInfo.ArgType;
817 FromExpr = FlatTree[ReadNode].FromArgInfo.ArgExpr;
818 ToExpr = FlatTree[ReadNode].ToArgInfo.ArgExpr;
822 bool &FromAddressOf,
bool &ToAddressOf,
823 bool &FromNullPtr,
bool &ToNullPtr,
Expr *&FromExpr,
825 assert(FlatTree[ReadNode].Kind == Declaration &&
"Unexpected kind.");
826 FromValueDecl = FlatTree[ReadNode].FromArgInfo.VD;
827 ToValueDecl = FlatTree[ReadNode].ToArgInfo.VD;
828 FromAddressOf = FlatTree[ReadNode].FromArgInfo.NeedAddressOf;
829 ToAddressOf = FlatTree[ReadNode].ToArgInfo.NeedAddressOf;
830 FromNullPtr = FlatTree[ReadNode].FromArgInfo.IsNullPtr;
831 ToNullPtr = FlatTree[ReadNode].ToArgInfo.IsNullPtr;
832 FromExpr = FlatTree[ReadNode].FromArgInfo.ArgExpr;
833 ToExpr = FlatTree[ReadNode].ToArgInfo.ArgExpr;
836 void GetFromDeclarationAndToIntegerDiff(
837 ValueDecl *&FromValueDecl,
bool &FromAddressOf,
bool &FromNullPtr,
840 assert(FlatTree[ReadNode].Kind == FromDeclarationAndToInteger &&
842 FromValueDecl = FlatTree[ReadNode].FromArgInfo.VD;
843 FromAddressOf = FlatTree[ReadNode].FromArgInfo.NeedAddressOf;
844 FromNullPtr = FlatTree[ReadNode].FromArgInfo.IsNullPtr;
845 FromExpr = FlatTree[ReadNode].FromArgInfo.ArgExpr;
846 ToInt = FlatTree[ReadNode].ToArgInfo.Val;
847 IsValidToInt = FlatTree[ReadNode].ToArgInfo.IsValidInt;
848 ToIntType = FlatTree[ReadNode].ToArgInfo.ArgType;
849 ToExpr = FlatTree[ReadNode].ToArgInfo.ArgExpr;
852 void GetFromIntegerAndToDeclarationDiff(
855 bool &ToNullPtr,
Expr *&ToExpr) {
856 assert(FlatTree[ReadNode].Kind == FromIntegerAndToDeclaration &&
858 FromInt = FlatTree[ReadNode].FromArgInfo.Val;
859 IsValidFromInt = FlatTree[ReadNode].FromArgInfo.IsValidInt;
860 FromIntType = FlatTree[ReadNode].FromArgInfo.ArgType;
861 FromExpr = FlatTree[ReadNode].FromArgInfo.ArgExpr;
862 ToValueDecl = FlatTree[ReadNode].ToArgInfo.VD;
863 ToAddressOf = FlatTree[ReadNode].ToArgInfo.NeedAddressOf;
864 ToNullPtr = FlatTree[ReadNode].ToArgInfo.IsNullPtr;
865 ToExpr = FlatTree[ReadNode].ToArgInfo.ArgExpr;
870 return FlatTree[ReadNode].FromArgInfo.IsDefault;
875 return FlatTree[ReadNode].ToArgInfo.IsDefault;
880 return FlatTree[ReadNode].Same;
885 return FlatTree[ReadNode].ChildNode != 0;
890 ReadNode = FlatTree[ReadNode].ChildNode;
895 bool AdvanceSibling() {
896 if (FlatTree[ReadNode].NextNode == 0)
899 ReadNode = FlatTree[ReadNode].NextNode;
904 bool HasNextSibling() {
905 return FlatTree[ReadNode].NextNode != 0;
910 return GetKind() == Invalid;
915 return FlatTree[ReadNode].Kind;
932 struct InternalIterator {
950 : TST(TST), Index(0), CurrentTA(
nullptr), EndTA(
nullptr) {
964 if (CurrentTA != EndTA)
return;
972 bool isValid()
const {
return TST; }
976 assert(TST &&
"InternalIterator is invalid with a null TST.");
981 InternalIterator &operator++() {
982 assert(TST &&
"InternalIterator is invalid with a null TST.");
988 if (CurrentTA != EndTA) {
990 if (CurrentTA != EndTA)
1010 if (CurrentTA != EndTA)
1018 assert(TST &&
"InternalIterator is invalid with a null TST.");
1019 assert(!isEnd() &&
"Index exceeds number of arguments.");
1020 if (CurrentTA == EndTA)
1021 return TST->
getArg(Index);
1027 pointer operator->()
const {
1028 assert(TST &&
"InternalIterator is invalid with a null TST.");
1033 InternalIterator SugaredIterator;
1034 InternalIterator DesugaredIterator;
1038 : SugaredIterator(TST),
1041 ? GetTemplateSpecializationType(Context, TST->
desugar())
1045 TSTiterator &operator++() {
1047 if (DesugaredIterator.isValid())
1048 ++DesugaredIterator;
1054 return *SugaredIterator;
1058 pointer operator->()
const {
1063 bool isEnd()
const {
1064 return SugaredIterator.isEnd();
1069 bool hasDesugaredTA()
const {
1070 return DesugaredIterator.isValid() && !DesugaredIterator.isEnd();
1074 reference getDesugaredTA()
const {
1075 assert(DesugaredIterator.isValid() &&
1076 "Desugared TemplateArgument should not be used.");
1077 return *DesugaredIterator;
1120 FromArgTST = GetTemplateSpecializationType(Context, FromType);
1121 ToArgTST = GetTemplateSpecializationType(Context, ToType);
1123 if (!FromArgTST || !ToArgTST)
1126 if (!hasSameTemplate(FromArgTST, ToArgTST))
1133 void DiffTypes(
const TSTiterator &FromIter,
const TSTiterator &ToIter) {
1134 QualType FromType = GetType(FromIter);
1137 bool FromDefault = FromIter.isEnd() && !FromType.
isNull();
1138 bool ToDefault = ToIter.isEnd() && !ToType.
isNull();
1142 if (OnlyPerformTypeDiff(Context, FromType, ToType, FromArgTST, ToArgTST)) {
1143 Tree.SetTypeDiff(FromType, ToType, FromDefault, ToDefault);
1147 assert(FromArgTST && ToArgTST &&
1148 "Both template specializations need to be valid.");
1155 FromQual, ToQual, FromDefault, ToDefault);
1156 DiffTemplate(FromArgTST, ToArgTST);
1162 void DiffTemplateTemplates(
const TSTiterator &FromIter,
1163 const TSTiterator &ToIter) {
1166 Tree.SetTemplateTemplateDiff(FromDecl, ToDecl, FromIter.isEnd() &&
FromDecl,
1167 ToIter.isEnd() && ToDecl);
1168 Tree.SetSame(FromDecl && ToDecl &&
1173 static void InitializeNonTypeDiffVariables(
ASTContext &Context,
1174 const TSTiterator &Iter,
1177 QualType &IntType,
bool &IsNullPtr,
1179 bool &NeedAddressOf) {
1180 if (!Iter.isEnd()) {
1181 switch (Iter->getKind()) {
1183 llvm_unreachable(
"unknown ArgumentKind");
1185 Value = Iter->getAsIntegral();
1187 IntType = Iter->getIntegralType();
1190 VD = Iter->getAsDecl();
1191 QualType ArgType = Iter->getParamTypeForDecl();
1195 NeedAddressOf =
true;
1202 E = Iter->getAsExpr();
1208 if (!Iter.hasDesugaredTA())
return;
1213 llvm_unreachable(
"unknown ArgumentKind");
1225 NeedAddressOf =
true;
1243 void DiffNonTypes(
const TSTiterator &FromIter,
const TSTiterator &ToIter,
1246 Expr *FromExpr =
nullptr, *ToExpr =
nullptr;
1249 ValueDecl *FromValueDecl =
nullptr, *ToValueDecl =
nullptr;
1250 bool HasFromInt =
false, HasToInt =
false, FromNullPtr =
false,
1251 ToNullPtr =
false, NeedFromAddressOf =
false, NeedToAddressOf =
false;
1252 InitializeNonTypeDiffVariables(
1253 Context, FromIter, FromDefaultNonTypeDecl, FromInt, HasFromInt,
1254 FromIntType, FromNullPtr, FromExpr, FromValueDecl, NeedFromAddressOf);
1255 InitializeNonTypeDiffVariables(Context, ToIter, ToDefaultNonTypeDecl, ToInt,
1256 HasToInt, ToIntType, ToNullPtr, ToExpr,
1257 ToValueDecl, NeedToAddressOf);
1259 bool FromDefault = FromIter.isEnd() &&
1260 (FromExpr || FromValueDecl || HasFromInt || FromNullPtr);
1261 bool ToDefault = ToIter.isEnd() &&
1262 (ToExpr || ToValueDecl || HasToInt || ToNullPtr);
1264 bool FromDeclaration = FromValueDecl || FromNullPtr;
1265 bool ToDeclaration = ToValueDecl || ToNullPtr;
1267 if (FromDeclaration && HasToInt) {
1268 Tree.SetFromDeclarationAndToIntegerDiff(
1269 FromValueDecl, NeedFromAddressOf, FromNullPtr, FromExpr, ToInt,
1270 HasToInt, ToIntType, ToExpr, FromDefault, ToDefault);
1271 Tree.SetSame(
false);
1276 if (HasFromInt && ToDeclaration) {
1277 Tree.SetFromIntegerAndToDeclarationDiff(
1278 FromInt, HasFromInt, FromIntType, FromExpr, ToValueDecl,
1279 NeedToAddressOf, ToNullPtr, ToExpr, FromDefault, ToDefault);
1280 Tree.SetSame(
false);
1284 if (HasFromInt || HasToInt) {
1285 Tree.SetIntegerDiff(FromInt, ToInt, HasFromInt, HasToInt, FromIntType,
1286 ToIntType, FromExpr, ToExpr, FromDefault, ToDefault);
1287 if (HasFromInt && HasToInt) {
1288 Tree.SetSame(Context.
hasSameType(FromIntType, ToIntType) &&
1294 if (FromDeclaration || ToDeclaration) {
1295 Tree.SetDeclarationDiff(FromValueDecl, ToValueDecl, NeedFromAddressOf,
1296 NeedToAddressOf, FromNullPtr, ToNullPtr, FromExpr,
1297 ToExpr, FromDefault, ToDefault);
1298 bool BothNull = FromNullPtr && ToNullPtr;
1299 bool SameValueDecl =
1300 FromValueDecl && ToValueDecl &&
1301 NeedFromAddressOf == NeedToAddressOf &&
1303 Tree.SetSame(BothNull || SameValueDecl);
1307 assert((FromExpr || ToExpr) &&
"Both template arguments cannot be empty.");
1308 Tree.SetExpressionDiff(FromExpr, ToExpr, FromDefault, ToDefault);
1309 Tree.SetSame(IsEqualExpr(Context, FromExpr, ToExpr));
1321 unsigned TotalArgs = 0;
1322 for (TSTiterator FromIter(Context, FromTST), ToIter(Context, ToTST);
1323 !FromIter.isEnd() || !ToIter.isEnd(); ++TotalArgs) {
1329 unsigned FromParamIndex =
std::min(TotalArgs, ParamsFrom->
size() - 1);
1330 unsigned ToParamIndex =
std::min(TotalArgs, ParamsTo->
size() - 1);
1334 assert(FromParamND->getKind() == ToParamND->
getKind() &&
1335 "Parameter Decl are not the same kind.");
1337 if (isa<TemplateTypeParmDecl>(FromParamND)) {
1338 DiffTypes(FromIter, ToIter);
1339 }
else if (isa<TemplateTemplateParmDecl>(FromParamND)) {
1340 DiffTemplateTemplates(FromIter, ToIter);
1341 }
else if (isa<NonTypeTemplateParmDecl>(FromParamND)) {
1343 cast<NonTypeTemplateParmDecl>(FromParamND);
1345 cast<NonTypeTemplateParmDecl>(ToParamND);
1346 DiffNonTypes(FromIter, ToIter, FromDefaultNonTypeDecl,
1347 ToDefaultNonTypeDecl);
1349 llvm_unreachable(
"Unexpected Decl type.");
1359 static void makeTemplateList(
1363 TemplateList.push_back(TST);
1385 if (hasSameBaseTemplate(FromTST, ToTST))
1392 makeTemplateList(FromTemplateList, FromTST);
1393 makeTemplateList(ToTemplateList, ToTST);
1396 FromIter = FromTemplateList.rbegin(), FromEnd = FromTemplateList.rend(),
1397 ToIter = ToTemplateList.rbegin(), ToEnd = ToTemplateList.rend();
1400 if (!hasSameBaseTemplate(*FromIter, *ToIter))
1406 for (; FromIter != FromEnd && ToIter != ToEnd; ++FromIter, ++ToIter) {
1407 if (!hasSameBaseTemplate(*FromIter, *ToIter))
1411 FromTST = FromIter[-1];
1419 static QualType GetType(
const TSTiterator &Iter) {
1421 return Iter->getAsType();
1422 if (Iter.hasDesugaredTA())
1423 return Iter.getDesugaredTA().getAsType();
1429 static TemplateDecl *GetTemplateDecl(
const TSTiterator &Iter) {
1431 return Iter->getAsTemplate().getAsTemplateDecl();
1432 if (Iter.hasDesugaredTA())
1433 return Iter.getDesugaredTA().getAsTemplate().getAsTemplateDecl();
1441 if (FromExpr == ToExpr)
1444 if (!FromExpr || !ToExpr)
1447 llvm::FoldingSetNodeID FromID, ToID;
1448 FromExpr->
Profile(FromID, Context,
true);
1449 ToExpr->
Profile(ToID, Context,
true);
1450 return FromID == ToID;
1458 void TreeToString(
int Indent = 1) {
1467 switch (Tree.GetKind()) {
1468 case DiffTree::Invalid:
1469 llvm_unreachable(
"Template diffing failed with bad DiffNode");
1472 Tree.GetTypeDiff(FromType, ToType);
1473 PrintTypeNames(FromType, ToType, Tree.FromDefault(), Tree.ToDefault(),
1477 case DiffTree::Expression: {
1478 Expr *FromExpr, *ToExpr;
1479 Tree.GetExpressionDiff(FromExpr, ToExpr);
1480 PrintExpr(FromExpr, ToExpr, Tree.FromDefault(), Tree.ToDefault(),
1484 case DiffTree::TemplateTemplate: {
1486 Tree.GetTemplateTemplateDiff(FromTD, ToTD);
1487 PrintTemplateTemplate(FromTD, ToTD, Tree.FromDefault(),
1488 Tree.ToDefault(), Tree.NodeIsSame());
1491 case DiffTree::Integer: {
1493 Expr *FromExpr, *ToExpr;
1494 bool IsValidFromInt, IsValidToInt;
1496 Tree.GetIntegerDiff(FromInt, ToInt, IsValidFromInt, IsValidToInt,
1497 FromIntType, ToIntType, FromExpr, ToExpr);
1498 PrintAPSInt(FromInt, ToInt, IsValidFromInt, IsValidToInt, FromIntType,
1499 ToIntType, FromExpr, ToExpr, Tree.FromDefault(),
1500 Tree.ToDefault(), Tree.NodeIsSame());
1503 case DiffTree::Declaration: {
1505 bool FromAddressOf, ToAddressOf;
1506 bool FromNullPtr, ToNullPtr;
1507 Expr *FromExpr, *ToExpr;
1508 Tree.GetDeclarationDiff(FromValueDecl, ToValueDecl, FromAddressOf,
1509 ToAddressOf, FromNullPtr, ToNullPtr, FromExpr,
1511 PrintValueDecl(FromValueDecl, ToValueDecl, FromAddressOf, ToAddressOf,
1512 FromNullPtr, ToNullPtr, FromExpr, ToExpr,
1513 Tree.FromDefault(), Tree.ToDefault(), Tree.NodeIsSame());
1516 case DiffTree::FromDeclarationAndToInteger: {
1525 Tree.GetFromDeclarationAndToIntegerDiff(
1526 FromValueDecl, FromAddressOf, FromNullPtr, FromExpr, ToInt,
1527 IsValidToInt, ToIntType, ToExpr);
1528 assert((FromValueDecl || FromNullPtr) && IsValidToInt);
1529 PrintValueDeclAndInteger(FromValueDecl, FromAddressOf, FromNullPtr,
1530 FromExpr, Tree.FromDefault(), ToInt, ToIntType,
1531 ToExpr, Tree.ToDefault());
1534 case DiffTree::FromIntegerAndToDeclaration: {
1536 bool IsValidFromInt;
1543 Tree.GetFromIntegerAndToDeclarationDiff(
1544 FromInt, IsValidFromInt, FromIntType, FromExpr, ToValueDecl,
1545 ToAddressOf, ToNullPtr, ToExpr);
1546 assert(IsValidFromInt && (ToValueDecl || ToNullPtr));
1547 PrintIntegerAndValueDecl(FromInt, FromIntType, FromExpr,
1548 Tree.FromDefault(), ToValueDecl, ToAddressOf,
1549 ToNullPtr, ToExpr, Tree.ToDefault());
1552 case DiffTree::Template: {
1556 Tree.GetTemplateDiff(FromTD, ToTD, FromQual, ToQual);
1558 PrintQualifiers(FromQual, ToQual);
1560 if (!Tree.HasChildren()) {
1569 unsigned NumElideArgs = 0;
1570 bool AllArgsElided =
true;
1573 if (Tree.NodeIsSame()) {
1577 AllArgsElided =
false;
1578 if (NumElideArgs > 0) {
1579 PrintElideArgs(NumElideArgs,
Indent);
1585 if (Tree.HasNextSibling())
1587 }
while (Tree.AdvanceSibling());
1588 if (NumElideArgs > 0) {
1592 PrintElideArgs(NumElideArgs,
Indent);
1608 assert(!IsBold &&
"Attempting to bold text that is already bold.");
1616 assert(IsBold &&
"Attempting to remove bold from unbold text.");
1628 bool FromDefault,
bool ToDefault,
bool Same) {
1630 "Only one template argument may be missing.");
1642 PrintQualifiers(FromQual, ToQual);
1647 std::string FromTypeStr = FromType.
isNull() ?
"(no argument)" 1649 std::string ToTypeStr = ToType.
isNull() ?
"(no argument)" 1653 if (FromTypeStr == ToTypeStr) {
1654 std::string FromCanTypeStr =
1657 if (FromCanTypeStr != ToCanTypeStr) {
1658 FromTypeStr = FromCanTypeStr;
1659 ToTypeStr = ToCanTypeStr;
1663 if (PrintTree) OS <<
'[';
1664 OS << (FromDefault ?
"(default) " :
"");
1669 OS <<
" != " << (ToDefault ?
"(default) " :
"");
1679 void PrintExpr(
const Expr *FromExpr,
const Expr *ToExpr,
bool FromDefault,
1680 bool ToDefault,
bool Same) {
1681 assert((FromExpr || ToExpr) &&
1682 "Only one template argument may be missing.");
1684 PrintExpr(FromExpr);
1685 }
else if (!PrintTree) {
1686 OS << (FromDefault ?
"(default) " :
"");
1688 PrintExpr(FromExpr);
1691 OS << (FromDefault ?
"[(default) " :
"[");
1693 PrintExpr(FromExpr);
1695 OS <<
" != " << (ToDefault ?
"(default) " :
"");
1704 void PrintExpr(
const Expr *E) {
1709 OS <<
"(no argument)";
1715 bool FromDefault,
bool ToDefault,
bool Same) {
1716 assert((FromTD || ToTD) &&
"Only one template argument may be missing.");
1718 std::string FromName = FromTD ? FromTD->
getName() :
"(no argument)";
1719 std::string ToName = ToTD ? ToTD->
getName() :
"(no argument)";
1720 if (FromTD && ToTD && FromName == ToName) {
1727 }
else if (!PrintTree) {
1728 OS << (FromDefault ?
"(default) template " :
"template ");
1733 OS << (FromDefault ?
"[(default) template " :
"[template ");
1737 OS <<
" != " << (ToDefault ?
"(default) template " :
"template ");
1748 bool IsValidFromInt,
bool IsValidToInt,
QualType FromIntType,
1750 bool FromDefault,
bool ToDefault,
bool Same) {
1751 assert((IsValidFromInt || IsValidToInt) &&
1752 "Only one integral argument may be missing.");
1756 OS << ((FromInt == 0) ?
"false" :
"true");
1758 OS << FromInt.toString(10);
1763 bool PrintType = IsValidFromInt && IsValidToInt &&
1767 OS << (FromDefault ?
"(default) " :
"");
1768 PrintAPSInt(FromInt, FromExpr, IsValidFromInt, FromIntType, PrintType);
1770 OS << (FromDefault ?
"[(default) " :
"[");
1771 PrintAPSInt(FromInt, FromExpr, IsValidFromInt, FromIntType, PrintType);
1772 OS <<
" != " << (ToDefault ?
"(default) " :
"");
1773 PrintAPSInt(ToInt, ToExpr, IsValidToInt, ToIntType, PrintType);
1781 QualType IntType,
bool PrintType) {
1784 if (HasExtraInfo(E)) {
1800 OS << ((Val == 0) ?
"false" :
"true");
1802 OS << Val.toString(10);
1807 OS <<
"(no argument)";
1814 bool HasExtraInfo(
Expr *E) {
1815 if (!E)
return false;
1819 if (isa<IntegerLiteral>(E))
return false;
1822 if (UO->getOpcode() == UO_Minus)
1823 if (isa<IntegerLiteral>(UO->getSubExpr()))
1826 if (isa<CXXBoolLiteralExpr>(E))
1832 void PrintValueDecl(
ValueDecl *VD,
bool AddressOf,
Expr *E,
bool NullPtr) {
1841 if (E && !isa<CXXNullPtrLiteralExpr>(E)) {
1856 OS <<
"(no argument)";
1862 bool FromAddressOf,
bool ToAddressOf,
bool FromNullPtr,
1863 bool ToNullPtr,
Expr *FromExpr,
Expr *ToExpr,
1864 bool FromDefault,
bool ToDefault,
bool Same) {
1865 assert((FromValueDecl || FromNullPtr || ToValueDecl || ToNullPtr) &&
1866 "Only one Decl argument may be NULL");
1869 PrintValueDecl(FromValueDecl, FromAddressOf, FromExpr, FromNullPtr);
1870 }
else if (!PrintTree) {
1871 OS << (FromDefault ?
"(default) " :
"");
1873 PrintValueDecl(FromValueDecl, FromAddressOf, FromExpr, FromNullPtr);
1876 OS << (FromDefault ?
"[(default) " :
"[");
1878 PrintValueDecl(FromValueDecl, FromAddressOf, FromExpr, FromNullPtr);
1880 OS <<
" != " << (ToDefault ?
"(default) " :
"");
1882 PrintValueDecl(ToValueDecl, ToAddressOf, ToExpr, ToNullPtr);
1890 void PrintValueDeclAndInteger(
ValueDecl *VD,
bool NeedAddressOf,
1891 bool IsNullPtr,
Expr *VDExpr,
bool DefaultDecl,
1893 Expr *IntExpr,
bool DefaultInt) {
1895 OS << (DefaultDecl ?
"(default) " :
"");
1897 PrintValueDecl(VD, NeedAddressOf, VDExpr, IsNullPtr);
1900 OS << (DefaultDecl ?
"[(default) " :
"[");
1902 PrintValueDecl(VD, NeedAddressOf, VDExpr, IsNullPtr);
1904 OS <<
" != " << (DefaultInt ?
"(default) " :
"");
1905 PrintAPSInt(Val, IntExpr,
true , IntType,
false );
1914 bool NeedAddressOf,
bool IsNullPtr,
1915 Expr *VDExpr,
bool DefaultDecl) {
1917 OS << (DefaultInt ?
"(default) " :
"");
1918 PrintAPSInt(Val, IntExpr,
true , IntType,
false );
1920 OS << (DefaultInt ?
"[(default) " :
"[");
1921 PrintAPSInt(Val, IntExpr,
true , IntType,
false );
1922 OS <<
" != " << (DefaultDecl ?
"(default) " :
"");
1924 PrintValueDecl(VD, NeedAddressOf, VDExpr, IsNullPtr);
1931 void PrintElideArgs(
unsigned NumElideArgs,
unsigned Indent) {
1934 for (
unsigned i = 0; i <
Indent; ++i)
1937 if (NumElideArgs == 0)
return;
1938 if (NumElideArgs == 1)
1941 OS <<
"[" << NumElideArgs <<
" * ...]";
1951 if (FromQual == ToQual) {
1952 PrintQualifier(FromQual,
false);
1972 if (CommonQual.
empty() && FromQual.
empty()) {
1974 OS <<
"(no qualifiers) ";
1977 PrintQualifier(CommonQual,
false);
1978 PrintQualifier(FromQual,
true);
1983 OS <<
"(no qualifiers)";
1986 PrintQualifier(CommonQual,
false,
1988 PrintQualifier(ToQual,
true,
1993 PrintQualifier(CommonQual,
false);
1994 PrintQualifier(FromQual,
true);
1998 void PrintQualifier(
Qualifiers Q,
bool ApplyBold,
1999 bool AppendSpaceIfNonEmpty =
true) {
2000 if (Q.
empty())
return;
2001 if (ApplyBold) Bold();
2002 Q.
print(OS, Policy, AppendSpaceIfNonEmpty);
2003 if (ApplyBold) Unbold();
2009 QualType ToType,
bool PrintTree,
bool PrintFromType,
2010 bool ElideType,
bool ShowColor)
2013 ElideType(ElideType),
2014 PrintTree(PrintTree),
2015 ShowColor(ShowColor),
2017 FromTemplateType(PrintFromType ? FromType : ToType),
2018 ToTemplateType(PrintFromType ? ToType : FromType),
2024 void DiffTemplate() {
2029 GetTemplateSpecializationType(Context, FromTemplateType);
2031 GetTemplateSpecializationType(Context, ToTemplateType);
2034 if (!FromOrigTST || !ToOrigTST)
2038 if (!hasSameTemplate(FromOrigTST, ToOrigTST)) {
2048 FromQual, ToQual,
false ,
2051 DiffTemplate(FromOrigTST, ToOrigTST);
2058 Tree.StartTraverse();
2063 assert(!IsBold &&
"Bold is applied to end of string.");
2074 bool PrintFromType,
bool ElideType,
2075 bool ShowColors, raw_ostream &OS) {
2077 PrintFromType =
true;
2078 TemplateDiff TD(OS, Context, FromType, ToType, PrintTree, PrintFromType,
2079 ElideType, ShowColors);
Defines the clang::ASTContext interface.
Represents a type that was referred to using an elaborated type keyword, e.g., struct S...
QualType getObjCObjectType(QualType Base, ObjCProtocolDecl *const *Protocols, unsigned NumProtocols) const
Legacy interface: cannot provide type arguments or __kindof.
const char * getSpelling() const
QualType getObjCIdType() const
Represents the Objective-CC id type.
PointerType - C99 6.7.5.1 - Pointer Declarators.
A (possibly-)qualified type.
QualType getBuiltinVaListType() const
Retrieve the type of the __builtin_va_list type.
FunctionType - C99 6.7.5.3 - Function Declarators.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
C Language Family Type Representation.
The template argument is an expression, and we've not resolved it to one of the other forms yet...
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type...
Defines the C++ template declaration subclasses.
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
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)
This file provides some common utility functions for processing Lambda related AST Constructs...
static Qualifiers fromOpaqueValue(unsigned opaque)
const T * getAs() const
Member-template getAs<specific type>'.
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, bool Canonical) const
Produce a unique representation of the given statement.
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.
QualType getLocalUnqualifiedType() const
Return this type with all of the instance-specific qualifiers removed, but without removing any quali...
Defines the clang::Expr interface and subclasses for C++ expressions.
QualType getIntegralType() const
Retrieve the type of the integral value.
The collection of all-type qualifiers we support.
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the class template specialization.
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...
Represents a class type in Objective C.
Expr * getAsExpr() const
Retrieve the template argument as an expression.
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...
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
TemplateName getTemplateName() const
Retrieve the name of the template that we are specializing.
clang::CharUnits operator*(clang::CharUnits::QuantityType Scale, const clang::CharUnits &CU)
QualType getParamTypeForDecl() const
Qualifiers getLocalQualifiers() const
Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...
An rvalue reference type, per C++11 [dcl.ref].
void print(raw_ostream &OS, const PrintingPolicy &Policy, const Twine &PlaceHolder=Twine(), unsigned Indentation=0) const
bool isTypeAlias() const
Determine if this template specialization type is for a type alias template that has been substituted...
Sugar type that represents a type that was qualified by a qualifier written as a macro invocation...
const clang::PrintingPolicy & getPrintingPolicy() const
Represents a declaration of a type.
static Qualifiers removeCommonQualifiers(Qualifiers &L, Qualifiers &R)
Returns the common set of qualifiers while removing them from the given sets.
bool isLambdaCallOperator(const CXXMethodDecl *MD)
void print(raw_ostream &OS, const PrintingPolicy &Policy, bool ResolveTemplateArguments=false) const
Print this nested name specifier to the given output stream.
QualType getObjCProtoType() const
Retrieve the type of the Objective-C Protocol class.
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Expr * IgnoreImpCasts() LLVM_READONLY
Skip past any implicit casts which might surround this expression until reaching a fixed point...
Represents a prototype with parameter type info, e.g.
bool isParameterPack() const
Whether this parameter is a non-type template parameter pack.
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
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...
void print(raw_ostream &OS, const PrintingPolicy &Policy, bool appendSpaceIfNonEmpty=false) const
unsigned TemplateDiffUsed
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
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)
Get a declaration name from an opaque integer returned by getAsOpaqueInteger.
static Optional< NullabilityKind > stripOuterNullability(QualType &T)
Strip off the top-level nullability annotation on the given type, if it's there.
UnaryOperator - This represents the unary-expression's (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
Represents a GCC generic vector type.
An lvalue reference type, per C++11 [dcl.ref].
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
static QualType Desugar(ASTContext &Context, QualType QT, bool &ShouldAKA)
bool isNull() const
Return true if this QualType doesn't point to a type yet.
QualType getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType)
const NamedDecl * FromDecl
RecordDecl * getDecl() const
QualType getBuiltinMSVaListType() const
Retrieve the type of the __builtin_ms_va_list type.
__INTPTR_TYPE__ intptr_t
A signed integer type with the property that any valid pointer to void can be converted to this type...
QualType getCanonicalType() const
param_type_range param_types() const
ExtProtoInfo getExtProtoInfo() const
Sugar for parentheses used when specifying types.
std::string getNameAsString() const
Get a human-readable name for the declaration, even if it is one of the special kinds of names (C++ c...
QualType getObjCSelType() const
Retrieve the type that corresponds to the predefined Objective-C 'SEL' type.
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>::".
TypeClass getTypeClass() const
llvm::APSInt getAsIntegral() const
Retrieve the template argument as an integral value.
static QualType getFromOpaquePtr(const void *Ptr)
ast_type_traits::DynTypedNode Node
Represents a template argument.
QualType getTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args, QualType Canon=QualType()) const
Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons...
Optional< types::ID > Type
Dataflow Directional Tag Classes.
virtual void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const
Appends a human-readable name for this declaration into the given 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.).
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
bool isBooleanType() const
const Type * strip(QualType type)
Collect any qualifiers on the given type and return an unqualified type.
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like 'int()'.
Expr * getDefaultArgument() const
Retrieve the default argument, if any.
static std::string getAddrSpaceAsString(LangAS AS)
QualType apply(const ASTContext &Context, QualType QT) const
Apply the collected qualifiers to the given type.
pack_iterator pack_begin() const
Iterator referencing the first argument of a template argument pack.
Represents a pointer to an Objective C object.
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.
unsigned getNumArgs() const
Retrieve the number of template arguments.
const TemplateArgument & getArg(unsigned Idx) const
Retrieve a specific template argument as a type.
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
The template argument is a type.
The template argument is actually a parameter pack.
pack_iterator pack_end() const
Iterator referencing one past the last argument of a template argument pack.
ArgKind getKind() const
Return the kind of stored template argument.
An attributed type is a type to which a type attribute has been applied.
void printPretty(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\, const ASTContext *Context=nullptr) const
QualType getAliasedType() const
Get the aliased type, if this is a specialization of a type alias template.
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type...
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
__DEVICE__ int min(int __a, int __b)
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
std::string getQualifiedNameAsString() const
QualType getAsType() const
Retrieve the type for a type template argument.
raw_ostream & Indent(raw_ostream &Out, const unsigned int Space, bool IsDot)
Represents a type template specialization; the template must be a class template, a type alias templa...
bool isPointerType() const
This represents a decl that may have a name.
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
bool isTranslationUnit() const
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 ...
const LangOptions & getLangOpts() const
Attr - This represents one attribute.