#include "clang/AST/ASTDiagnostic.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/DeclObjC.h"
#include "clang/AST/TemplateBase.h"
#include "clang/AST/ExprCXX.h"
#include "clang/AST/DeclTemplate.h"
#include "clang/AST/Type.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/Support/raw_ostream.h"
using namespace clang;
static QualType Desugar(ASTContext &Context, QualType QT, bool &ShouldAKA) {
QualifierCollector QC;
while (true) {
const Type *Ty = QC.strip(QT);
if (const ElaboratedType *ET = dyn_cast<ElaboratedType>(Ty)) {
QT = ET->desugar();
continue;
}
if (const ParenType *PT = dyn_cast<ParenType>(Ty)) {
QT = PT->desugar();
continue;
}
if (const SubstTemplateTypeParmType *ST =
dyn_cast<SubstTemplateTypeParmType>(Ty)) {
QT = ST->desugar();
continue;
}
if (const AttributedType *AT = dyn_cast<AttributedType>(Ty)) {
QT = AT->desugar();
continue;
}
if (const AutoType *AT = dyn_cast<AutoType>(Ty)) {
if (!AT->isSugared())
break;
QT = AT->desugar();
continue;
}
if (const TemplateSpecializationType *TST
= dyn_cast<TemplateSpecializationType>(Ty))
if (!TST->isTypeAlias())
break;
if (QualType(Ty,0) == Context.getObjCIdType() ||
QualType(Ty,0) == Context.getObjCClassType() ||
QualType(Ty,0) == Context.getObjCSelType() ||
QualType(Ty,0) == Context.getObjCProtoType())
break;
if (QualType(Ty,0) == Context.getBuiltinVaListType())
break;
QualType Underlying;
bool IsSugar = false;
switch (Ty->getTypeClass()) {
#define ABSTRACT_TYPE(Class, Base)
#define TYPE(Class, Base) \
case Type::Class: { \
const Class##Type *CTy = cast<Class##Type>(Ty); \
if (CTy->isSugared()) { \
IsSugar = true; \
Underlying = CTy->desugar(); \
} \
break; \
}
#include "clang/AST/TypeNodes.def"
}
if (!IsSugar)
break;
if (isa<VectorType>(Underlying))
break;
if (const TagType *UTT = Underlying->getAs<TagType>())
if (const TypedefType *QTT = dyn_cast<TypedefType>(QT))
if (UTT->getDecl()->getTypedefNameForAnonDecl() == QTT->getDecl())
break;
ShouldAKA = true;
QT = Underlying;
}
if (const PointerType *Ty = QT->getAs<PointerType>()) {
QT = Context.getPointerType(Desugar(Context, Ty->getPointeeType(),
ShouldAKA));
} else if (const LValueReferenceType *Ty = QT->getAs<LValueReferenceType>()) {
QT = Context.getLValueReferenceType(Desugar(Context, Ty->getPointeeType(),
ShouldAKA));
} else if (const RValueReferenceType *Ty = QT->getAs<RValueReferenceType>()) {
QT = Context.getRValueReferenceType(Desugar(Context, Ty->getPointeeType(),
ShouldAKA));
}
return QC.apply(Context, QT);
}
static std::string
ConvertTypeToDiagnosticString(ASTContext &Context, QualType Ty,
const DiagnosticsEngine::ArgumentValue *PrevArgs,
unsigned NumPrevArgs,
ArrayRef<intptr_t> QualTypeVals) {
bool ForceAKA = false;
QualType CanTy = Ty.getCanonicalType();
std::string S = Ty.getAsString(Context.getPrintingPolicy());
std::string CanS = CanTy.getAsString(Context.getPrintingPolicy());
for (unsigned I = 0, E = QualTypeVals.size(); I != E; ++I) {
QualType CompareTy =
QualType::getFromOpaquePtr(reinterpret_cast<void*>(QualTypeVals[I]));
if (CompareTy.isNull())
continue;
if (CompareTy == Ty)
continue; QualType CompareCanTy = CompareTy.getCanonicalType();
if (CompareCanTy == CanTy)
continue; std::string CompareS = CompareTy.getAsString(Context.getPrintingPolicy());
bool aka;
QualType CompareDesugar = Desugar(Context, CompareTy, aka);
std::string CompareDesugarStr =
CompareDesugar.getAsString(Context.getPrintingPolicy());
if (CompareS != S && CompareDesugarStr != S)
continue; std::string CompareCanS =
CompareCanTy.getAsString(Context.getPrintingPolicy());
if (CompareCanS == CanS)
continue;
ForceAKA = true;
break;
}
bool Repeated = false;
for (unsigned i = 0; i != NumPrevArgs; ++i) {
if (PrevArgs[i].first == DiagnosticsEngine::ak_qualtype) {
void *Ptr = (void*)PrevArgs[i].second;
QualType PrevTy(QualType::getFromOpaquePtr(Ptr));
if (PrevTy == Ty) {
Repeated = true;
break;
}
}
}
if (!Repeated) {
bool ShouldAKA = false;
QualType DesugaredTy = Desugar(Context, Ty, ShouldAKA);
if (ShouldAKA || ForceAKA) {
if (DesugaredTy == Ty) {
DesugaredTy = Ty.getCanonicalType();
}
std::string akaStr = DesugaredTy.getAsString(Context.getPrintingPolicy());
if (akaStr != S) {
S = "'" + S + "' (aka '" + akaStr + "')";
return S;
}
}
}
S = "'" + S + "'";
return S;
}
static bool FormatTemplateTypeDiff(ASTContext &Context, QualType FromType,
QualType ToType, bool PrintTree,
bool PrintFromType, bool ElideType,
bool ShowColors, std::string &S);
void clang::FormatASTNodeDiagnosticArgument(
DiagnosticsEngine::ArgumentKind Kind,
intptr_t Val,
const char *Modifier,
unsigned ModLen,
const char *Argument,
unsigned ArgLen,
const DiagnosticsEngine::ArgumentValue *PrevArgs,
unsigned NumPrevArgs,
SmallVectorImpl<char> &Output,
void *Cookie,
ArrayRef<intptr_t> QualTypeVals) {
ASTContext &Context = *static_cast<ASTContext*>(Cookie);
std::string S;
bool NeedQuotes = true;
switch (Kind) {
default: llvm_unreachable("unknown ArgumentKind");
case DiagnosticsEngine::ak_qualtype_pair: {
TemplateDiffTypes &TDT = *reinterpret_cast<TemplateDiffTypes*>(Val);
QualType FromType =
QualType::getFromOpaquePtr(reinterpret_cast<void*>(TDT.FromType));
QualType ToType =
QualType::getFromOpaquePtr(reinterpret_cast<void*>(TDT.ToType));
if (FormatTemplateTypeDiff(Context, FromType, ToType, TDT.PrintTree,
TDT.PrintFromType, TDT.ElideType,
TDT.ShowColors, S)) {
NeedQuotes = !TDT.PrintTree;
TDT.TemplateDiffUsed = true;
break;
}
if (TDT.PrintTree)
return;
Val = TDT.PrintFromType ? TDT.FromType : TDT.ToType;
ModLen = 0;
ArgLen = 0;
}
case DiagnosticsEngine::ak_qualtype: {
assert(ModLen == 0 && ArgLen == 0 &&
"Invalid modifier for QualType argument");
QualType Ty(QualType::getFromOpaquePtr(reinterpret_cast<void*>(Val)));
S = ConvertTypeToDiagnosticString(Context, Ty, PrevArgs, NumPrevArgs,
QualTypeVals);
NeedQuotes = false;
break;
}
case DiagnosticsEngine::ak_declarationname: {
DeclarationName N = DeclarationName::getFromOpaqueInteger(Val);
S = N.getAsString();
if (ModLen == 9 && !memcmp(Modifier, "objcclass", 9) && ArgLen == 0)
S = '+' + S;
else if (ModLen == 12 && !memcmp(Modifier, "objcinstance", 12)
&& ArgLen==0)
S = '-' + S;
else
assert(ModLen == 0 && ArgLen == 0 &&
"Invalid modifier for DeclarationName argument");
break;
}
case DiagnosticsEngine::ak_nameddecl: {
bool Qualified;
if (ModLen == 1 && Modifier[0] == 'q' && ArgLen == 0)
Qualified = true;
else {
assert(ModLen == 0 && ArgLen == 0 &&
"Invalid modifier for NamedDecl* argument");
Qualified = false;
}
const NamedDecl *ND = reinterpret_cast<const NamedDecl*>(Val);
ND->getNameForDiagnostic(S, Context.getPrintingPolicy(), Qualified);
break;
}
case DiagnosticsEngine::ak_nestednamespec: {
llvm::raw_string_ostream OS(S);
reinterpret_cast<NestedNameSpecifier*>(Val)->print(OS,
Context.getPrintingPolicy());
NeedQuotes = false;
break;
}
case DiagnosticsEngine::ak_declcontext: {
DeclContext *DC = reinterpret_cast<DeclContext *> (Val);
assert(DC && "Should never have a null declaration context");
if (DC->isTranslationUnit()) {
if (Context.getLangOpts().CPlusPlus)
S = "the global namespace";
else
S = "the global scope";
} else if (TypeDecl *Type = dyn_cast<TypeDecl>(DC)) {
S = ConvertTypeToDiagnosticString(Context,
Context.getTypeDeclType(Type),
PrevArgs, NumPrevArgs, QualTypeVals);
} else {
NamedDecl *ND = cast<NamedDecl>(DC);
if (isa<NamespaceDecl>(ND))
S += "namespace ";
else if (isa<ObjCMethodDecl>(ND))
S += "method ";
else if (isa<FunctionDecl>(ND))
S += "function ";
S += "'";
ND->getNameForDiagnostic(S, Context.getPrintingPolicy(), true);
S += "'";
}
NeedQuotes = false;
break;
}
}
if (NeedQuotes)
Output.push_back('\'');
Output.append(S.begin(), S.end());
if (NeedQuotes)
Output.push_back('\'');
}
namespace {
class TemplateDiff {
ASTContext &Context;
PrintingPolicy Policy;
bool ElideType;
bool PrintTree;
bool ShowColor;
QualType FromType;
QualType ToType;
llvm::SmallString<128> Str;
llvm::raw_svector_ostream OS;
bool IsBold;
class DiffTree {
struct DiffNode {
unsigned NextNode;
unsigned ChildNode;
unsigned ParentNode;
QualType FromType, ToType;
Expr *FromExpr, *ToExpr;
TemplateDecl *FromTD, *ToTD;
Qualifiers FromQual, ToQual;
bool FromDefault, ToDefault;
bool Same;
DiffNode(unsigned ParentNode = 0)
: NextNode(0), ChildNode(0), ParentNode(ParentNode),
FromType(), ToType(), FromExpr(0), ToExpr(0), FromTD(0), ToTD(0),
FromDefault(false), ToDefault(false), Same(false) { }
};
llvm::SmallVector<DiffNode, 16> FlatTree;
unsigned CurrentNode;
unsigned NextFreeNode;
unsigned ReadNode;
public:
DiffTree() :
CurrentNode(0), NextFreeNode(1) {
FlatTree.push_back(DiffNode());
}
void SetNode(TemplateDecl *FromTD, TemplateDecl *ToTD) {
FlatTree[CurrentNode].FromTD = FromTD;
FlatTree[CurrentNode].ToTD = ToTD;
}
void SetNode(QualType FromType, QualType ToType) {
FlatTree[CurrentNode].FromType = FromType;
FlatTree[CurrentNode].ToType = ToType;
}
void SetNode(Expr *FromExpr, Expr *ToExpr) {
FlatTree[CurrentNode].FromExpr = FromExpr;
FlatTree[CurrentNode].ToExpr = ToExpr;
}
void SetNode(Qualifiers FromQual, Qualifiers ToQual) {
FlatTree[CurrentNode].FromQual = FromQual;
FlatTree[CurrentNode].ToQual = ToQual;
}
void SetSame(bool Same) {
FlatTree[CurrentNode].Same = Same;
}
void SetDefault(bool FromDefault, bool ToDefault) {
FlatTree[CurrentNode].FromDefault = FromDefault;
FlatTree[CurrentNode].ToDefault = ToDefault;
}
void Up() {
CurrentNode = FlatTree[CurrentNode].ParentNode;
}
void AddNode() {
FlatTree.push_back(DiffNode(CurrentNode));
DiffNode &Node = FlatTree[CurrentNode];
if (Node.ChildNode == 0) {
Node.ChildNode = NextFreeNode;
} else {
unsigned i;
for (i = Node.ChildNode; FlatTree[i].NextNode != 0;
i = FlatTree[i].NextNode) {
}
FlatTree[i].NextNode = NextFreeNode;
}
CurrentNode = NextFreeNode;
++NextFreeNode;
}
void StartTraverse() {
ReadNode = 0;
CurrentNode = NextFreeNode;
NextFreeNode = 0;
}
void Parent() {
ReadNode = FlatTree[ReadNode].ParentNode;
}
bool NodeIsTemplate() {
return (FlatTree[ReadNode].FromTD &&
!FlatTree[ReadNode].ToType.isNull()) ||
(FlatTree[ReadNode].ToTD && !FlatTree[ReadNode].ToType.isNull());
}
bool NodeIsQualType() {
return !FlatTree[ReadNode].FromType.isNull() ||
!FlatTree[ReadNode].ToType.isNull();
}
bool NodeIsExpr() {
return FlatTree[ReadNode].FromExpr || FlatTree[ReadNode].ToExpr;
}
bool NodeIsTemplateTemplate() {
return FlatTree[ReadNode].FromType.isNull() &&
FlatTree[ReadNode].ToType.isNull() &&
(FlatTree[ReadNode].FromTD || FlatTree[ReadNode].ToTD);
}
void GetNode(QualType &FromType, QualType &ToType) {
FromType = FlatTree[ReadNode].FromType;
ToType = FlatTree[ReadNode].ToType;
}
void GetNode(Expr *&FromExpr, Expr *&ToExpr) {
FromExpr = FlatTree[ReadNode].FromExpr;
ToExpr = FlatTree[ReadNode].ToExpr;
}
void GetNode(TemplateDecl *&FromTD, TemplateDecl *&ToTD) {
FromTD = FlatTree[ReadNode].FromTD;
ToTD = FlatTree[ReadNode].ToTD;
}
void GetNode(Qualifiers &FromQual, Qualifiers &ToQual) {
FromQual = FlatTree[ReadNode].FromQual;
ToQual = FlatTree[ReadNode].ToQual;
}
bool NodeIsSame() {
return FlatTree[ReadNode].Same;
}
bool HasChildren() {
return FlatTree[ReadNode].ChildNode != 0;
}
void MoveToChild() {
ReadNode = FlatTree[ReadNode].ChildNode;
}
bool AdvanceSibling() {
if (FlatTree[ReadNode].NextNode == 0)
return false;
ReadNode = FlatTree[ReadNode].NextNode;
return true;
}
bool HasNextSibling() {
return FlatTree[ReadNode].NextNode != 0;
}
bool FromDefault() {
return FlatTree[ReadNode].FromDefault;
}
bool ToDefault() {
return FlatTree[ReadNode].ToDefault;
}
bool Empty() {
return !FlatTree[0].FromTD && !FlatTree[0].ToTD &&
!FlatTree[0].FromExpr && !FlatTree[0].ToExpr &&
FlatTree[0].FromType.isNull() && FlatTree[0].ToType.isNull();
}
};
DiffTree Tree;
struct TSTiterator {
typedef const TemplateArgument& reference;
typedef const TemplateArgument* pointer;
const TemplateSpecializationType *TST;
unsigned Index;
TemplateArgument::pack_iterator CurrentTA;
TemplateArgument::pack_iterator EndTA;
TSTiterator(const TemplateSpecializationType *TST)
: TST(TST), Index(0), CurrentTA(0), EndTA(0) {
if (isEnd()) return;
TemplateArgument TA = TST->getArg(0);
if (TA.getKind() != TemplateArgument::Pack) return;
CurrentTA = TA.pack_begin();
EndTA = TA.pack_end();
if (CurrentTA != EndTA) return;
++(*this);
}
bool isEnd() const {
return Index == TST->getNumArgs();
}
TSTiterator &operator++() {
assert(!isEnd() && "Iterator incremented past end of arguments.");
if (CurrentTA != EndTA) {
++CurrentTA;
if (CurrentTA != EndTA)
return *this;
}
while (true) {
if (++Index == TST->getNumArgs()) break;
TemplateArgument TA = TST->getArg(Index);
if (TA.getKind() != TemplateArgument::Pack) break;
CurrentTA = TA.pack_begin();
EndTA = TA.pack_end();
if (CurrentTA != EndTA) break;
}
return *this;
}
reference operator*() const {
assert(!isEnd() && "Index exceeds number of arguments.");
if (CurrentTA == EndTA)
return TST->getArg(Index);
else
return *CurrentTA;
}
pointer operator->() const {
return &operator*();
}
};
static const TemplateSpecializationType * GetTemplateSpecializationType(
ASTContext &Context, QualType Ty) {
if (const TemplateSpecializationType *TST =
Ty->getAs<TemplateSpecializationType>())
return TST;
const RecordType *RT = Ty->getAs<RecordType>();
if (!RT)
return 0;
const ClassTemplateSpecializationDecl *CTSD =
dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl());
if (!CTSD)
return 0;
Ty = Context.getTemplateSpecializationType(
TemplateName(CTSD->getSpecializedTemplate()),
CTSD->getTemplateArgs().data(),
CTSD->getTemplateArgs().size(),
Ty.getCanonicalType());
return Ty->getAs<TemplateSpecializationType>();
}
void DiffTemplate(const TemplateSpecializationType *FromTST,
const TemplateSpecializationType *ToTST) {
TemplateParameterList *Params =
FromTST->getTemplateName().getAsTemplateDecl()->getTemplateParameters();
unsigned TotalArgs = 0;
for (TSTiterator FromIter(FromTST), ToIter(ToTST);
!FromIter.isEnd() || !ToIter.isEnd(); ++TotalArgs) {
Tree.AddNode();
NamedDecl *ParamND = Params->getParam(
(TotalArgs < Params->size()) ? TotalArgs
: Params->size() - 1);
if (TemplateTypeParmDecl *DefaultTTPD =
dyn_cast<TemplateTypeParmDecl>(ParamND)) {
QualType FromType, ToType;
GetType(FromIter, DefaultTTPD, FromType);
GetType(ToIter, DefaultTTPD, ToType);
Tree.SetNode(FromType, ToType);
Tree.SetDefault(FromIter.isEnd() && !FromType.isNull(),
ToIter.isEnd() && !ToType.isNull());
if (!FromType.isNull() && !ToType.isNull()) {
if (Context.hasSameType(FromType, ToType)) {
Tree.SetSame(true);
} else {
Qualifiers FromQual = FromType.getQualifiers(),
ToQual = ToType.getQualifiers();
const TemplateSpecializationType *FromArgTST =
GetTemplateSpecializationType(Context, FromType);
const TemplateSpecializationType *ToArgTST =
GetTemplateSpecializationType(Context, ToType);
if (FromArgTST && ToArgTST &&
hasSameTemplate(FromArgTST, ToArgTST)) {
FromQual -= QualType(FromArgTST, 0).getQualifiers();
ToQual -= QualType(ToArgTST, 0).getQualifiers();
Tree.SetNode(FromArgTST->getTemplateName().getAsTemplateDecl(),
ToArgTST->getTemplateName().getAsTemplateDecl());
Tree.SetNode(FromQual, ToQual);
DiffTemplate(FromArgTST, ToArgTST);
}
}
}
}
if (NonTypeTemplateParmDecl *DefaultNTTPD =
dyn_cast<NonTypeTemplateParmDecl>(ParamND)) {
Expr *FromExpr, *ToExpr;
GetExpr(FromIter, DefaultNTTPD, FromExpr);
GetExpr(ToIter, DefaultNTTPD, ToExpr);
Tree.SetNode(FromExpr, ToExpr);
Tree.SetSame(IsEqualExpr(Context, FromExpr, ToExpr));
Tree.SetDefault(FromIter.isEnd() && FromExpr,
ToIter.isEnd() && ToExpr);
}
if (TemplateTemplateParmDecl *DefaultTTPD =
dyn_cast<TemplateTemplateParmDecl>(ParamND)) {
TemplateDecl *FromDecl, *ToDecl;
GetTemplateDecl(FromIter, DefaultTTPD, FromDecl);
GetTemplateDecl(ToIter, DefaultTTPD, ToDecl);
Tree.SetNode(FromDecl, ToDecl);
Tree.SetSame(FromDecl && ToDecl &&
FromDecl->getIdentifier() == ToDecl->getIdentifier());
}
if (!FromIter.isEnd()) ++FromIter;
if (!ToIter.isEnd()) ++ToIter;
Tree.Up();
}
}
static void makeTemplateList(
SmallVector<const TemplateSpecializationType*, 1> &TemplateList,
const TemplateSpecializationType *TST) {
while (TST) {
TemplateList.push_back(TST);
if (!TST->isTypeAlias())
return;
TST = TST->getAliasedType()->getAs<TemplateSpecializationType>();
}
}
static bool hasSameBaseTemplate(const TemplateSpecializationType *FromTST,
const TemplateSpecializationType *ToTST) {
return FromTST->getTemplateName().getAsTemplateDecl()->getIdentifier() ==
ToTST->getTemplateName().getAsTemplateDecl()->getIdentifier();
}
static bool hasSameTemplate(const TemplateSpecializationType *&FromTST,
const TemplateSpecializationType *&ToTST) {
if (hasSameBaseTemplate(FromTST, ToTST))
return true;
SmallVector<const TemplateSpecializationType*, 1> FromTemplateList,
ToTemplateList;
makeTemplateList(FromTemplateList, FromTST);
makeTemplateList(ToTemplateList, ToTST);
SmallVector<const TemplateSpecializationType*, 1>::reverse_iterator
FromIter = FromTemplateList.rbegin(), FromEnd = FromTemplateList.rend(),
ToIter = ToTemplateList.rbegin(), ToEnd = ToTemplateList.rend();
if (!hasSameBaseTemplate(*FromIter, *ToIter))
return false;
for (; FromIter != FromEnd && ToIter != ToEnd; ++FromIter, ++ToIter) {
if (!hasSameBaseTemplate(*FromIter, *ToIter))
break;
}
FromTST = FromIter[-1];
ToTST = ToIter[-1];
return true;
}
void GetType(const TSTiterator &Iter, TemplateTypeParmDecl *DefaultTTPD,
QualType &ArgType) {
ArgType = QualType();
bool isVariadic = DefaultTTPD->isParameterPack();
if (!Iter.isEnd())
ArgType = Iter->getAsType();
else if (!isVariadic)
ArgType = DefaultTTPD->getDefaultArgument();
}
void GetExpr(const TSTiterator &Iter, NonTypeTemplateParmDecl *DefaultNTTPD,
Expr *&ArgExpr) {
ArgExpr = 0;
bool isVariadic = DefaultNTTPD->isParameterPack();
if (!Iter.isEnd())
ArgExpr = Iter->getAsExpr();
else if (!isVariadic)
ArgExpr = DefaultNTTPD->getDefaultArgument();
if (ArgExpr)
while (SubstNonTypeTemplateParmExpr *SNTTPE =
dyn_cast<SubstNonTypeTemplateParmExpr>(ArgExpr))
ArgExpr = SNTTPE->getReplacement();
}
void GetTemplateDecl(const TSTiterator &Iter,
TemplateTemplateParmDecl *DefaultTTPD,
TemplateDecl *&ArgDecl) {
ArgDecl = 0;
bool isVariadic = DefaultTTPD->isParameterPack();
TemplateArgument TA = DefaultTTPD->getDefaultArgument().getArgument();
TemplateDecl *DefaultTD = 0;
if (TA.getKind() != TemplateArgument::Null)
DefaultTD = TA.getAsTemplate().getAsTemplateDecl();
if (!Iter.isEnd())
ArgDecl = Iter->getAsTemplate().getAsTemplateDecl();
else if (!isVariadic)
ArgDecl = DefaultTD;
}
static bool IsEqualExpr(ASTContext &Context, Expr *FromExpr, Expr *ToExpr) {
if (FromExpr == ToExpr)
return true;
if (!FromExpr || !ToExpr)
return false;
FromExpr = FromExpr->IgnoreParens();
ToExpr = ToExpr->IgnoreParens();
DeclRefExpr *FromDRE = dyn_cast<DeclRefExpr>(FromExpr),
*ToDRE = dyn_cast<DeclRefExpr>(ToExpr);
if (FromDRE || ToDRE) {
if (!FromDRE || !ToDRE)
return false;
return FromDRE->getDecl() == ToDRE->getDecl();
}
Expr::EvalResult FromResult, ToResult;
if (!FromExpr->EvaluateAsRValue(FromResult, Context) ||
!ToExpr->EvaluateAsRValue(ToResult, Context))
assert(0 && "Template arguments must be known at compile time.");
APValue &FromVal = FromResult.Val;
APValue &ToVal = ToResult.Val;
if (FromVal.getKind() != ToVal.getKind()) return false;
switch (FromVal.getKind()) {
case APValue::Int:
return FromVal.getInt() == ToVal.getInt();
case APValue::LValue: {
APValue::LValueBase FromBase = FromVal.getLValueBase();
APValue::LValueBase ToBase = ToVal.getLValueBase();
if (FromBase.isNull() && ToBase.isNull())
return true;
if (FromBase.isNull() || ToBase.isNull())
return false;
return FromBase.get<const ValueDecl*>() ==
ToBase.get<const ValueDecl*>();
}
case APValue::MemberPointer:
return FromVal.getMemberPointerDecl() == ToVal.getMemberPointerDecl();
default:
llvm_unreachable("Unknown template argument expression.");
}
}
void TreeToString(int Indent = 1) {
if (PrintTree) {
OS << '\n';
for (int i = 0; i < Indent; ++i)
OS << " ";
++Indent;
}
if (!Tree.NodeIsTemplate()) {
if (Tree.NodeIsQualType()) {
QualType FromType, ToType;
Tree.GetNode(FromType, ToType);
PrintTypeNames(FromType, ToType, Tree.FromDefault(), Tree.ToDefault(),
Tree.NodeIsSame());
return;
}
if (Tree.NodeIsExpr()) {
Expr *FromExpr, *ToExpr;
Tree.GetNode(FromExpr, ToExpr);
PrintExpr(FromExpr, ToExpr, Tree.FromDefault(), Tree.ToDefault(),
Tree.NodeIsSame());
return;
}
if (Tree.NodeIsTemplateTemplate()) {
TemplateDecl *FromTD, *ToTD;
Tree.GetNode(FromTD, ToTD);
PrintTemplateTemplate(FromTD, ToTD, Tree.FromDefault(),
Tree.ToDefault(), Tree.NodeIsSame());
return;
}
llvm_unreachable("Unable to deduce template difference.");
}
TemplateDecl *FromTD, *ToTD;
Tree.GetNode(FromTD, ToTD);
assert(Tree.HasChildren() && "Template difference not found in diff tree.");
Qualifiers FromQual, ToQual;
Tree.GetNode(FromQual, ToQual);
PrintQualifiers(FromQual, ToQual);
OS << FromTD->getNameAsString() << '<';
Tree.MoveToChild();
unsigned NumElideArgs = 0;
do {
if (ElideType) {
if (Tree.NodeIsSame()) {
++NumElideArgs;
continue;
}
if (NumElideArgs > 0) {
PrintElideArgs(NumElideArgs, Indent);
NumElideArgs = 0;
OS << ", ";
}
}
TreeToString(Indent);
if (Tree.HasNextSibling())
OS << ", ";
} while (Tree.AdvanceSibling());
if (NumElideArgs > 0)
PrintElideArgs(NumElideArgs, Indent);
Tree.Parent();
OS << ">";
}
void Bold() {
assert(!IsBold && "Attempting to bold text that is already bold.");
IsBold = true;
if (ShowColor)
OS << ToggleHighlight;
}
void Unbold() {
assert(IsBold && "Attempting to remove bold from unbold text.");
IsBold = false;
if (ShowColor)
OS << ToggleHighlight;
}
void PrintTypeNames(QualType FromType, QualType ToType,
bool FromDefault, bool ToDefault, bool Same) {
assert((!FromType.isNull() || !ToType.isNull()) &&
"Only one template argument may be missing.");
if (Same) {
OS << FromType.getAsString();
return;
}
if (!FromType.isNull() && !ToType.isNull() &&
FromType.getLocalUnqualifiedType() ==
ToType.getLocalUnqualifiedType()) {
Qualifiers FromQual = FromType.getLocalQualifiers(),
ToQual = ToType.getLocalQualifiers(),
CommonQual;
PrintQualifiers(FromQual, ToQual);
FromType.getLocalUnqualifiedType().print(OS, Policy);
return;
}
std::string FromTypeStr = FromType.isNull() ? "(no argument)"
: FromType.getAsString();
std::string ToTypeStr = ToType.isNull() ? "(no argument)"
: ToType.getAsString();
if (FromTypeStr == ToTypeStr) {
std::string FromCanTypeStr = FromType.getCanonicalType().getAsString();
std::string ToCanTypeStr = ToType.getCanonicalType().getAsString();
if (FromCanTypeStr != ToCanTypeStr) {
FromTypeStr = FromCanTypeStr;
ToTypeStr = ToCanTypeStr;
}
}
if (PrintTree) OS << '[';
OS << (FromDefault ? "(default) " : "");
Bold();
OS << FromTypeStr;
Unbold();
if (PrintTree) {
OS << " != " << (ToDefault ? "(default) " : "");
Bold();
OS << ToTypeStr;
Unbold();
OS << "]";
}
return;
}
void PrintExpr(const Expr *FromExpr, const Expr *ToExpr,
bool FromDefault, bool ToDefault, bool Same) {
assert((FromExpr || ToExpr) &&
"Only one template argument may be missing.");
if (Same) {
PrintExpr(FromExpr);
} else if (!PrintTree) {
OS << (FromDefault ? "(default) " : "");
Bold();
PrintExpr(FromExpr);
Unbold();
} else {
OS << (FromDefault ? "[(default) " : "[");
Bold();
PrintExpr(FromExpr);
Unbold();
OS << " != " << (ToDefault ? "(default) " : "");
Bold();
PrintExpr(ToExpr);
Unbold();
OS << ']';
}
}
void PrintExpr(const Expr *E) {
if (!E)
OS << "(no argument)";
else
E->printPretty(OS, 0, Policy); return;
}
void PrintTemplateTemplate(TemplateDecl *FromTD, TemplateDecl *ToTD,
bool FromDefault, bool ToDefault, bool Same) {
assert((FromTD || ToTD) && "Only one template argument may be missing.");
if (Same) {
OS << "template " << FromTD->getNameAsString();
} else if (!PrintTree) {
OS << (FromDefault ? "(default) template " : "template ");
Bold();
OS << (FromTD ? FromTD->getNameAsString() : "(no argument)");
Unbold();
} else {
OS << (FromDefault ? "[(default) template " : "[template ");
Bold();
OS << (FromTD ? FromTD->getNameAsString() : "(no argument)");
Unbold();
OS << " != " << (ToDefault ? "(default) template " : "template ");
Bold();
OS << (ToTD ? ToTD->getNameAsString() : "(no argument)");
Unbold();
OS << ']';
}
}
void PrintElideArgs(unsigned NumElideArgs, unsigned Indent) {
if (PrintTree) {
OS << '\n';
for (unsigned i = 0; i < Indent; ++i)
OS << " ";
}
if (NumElideArgs == 0) return;
if (NumElideArgs == 1)
OS << "[...]";
else
OS << "[" << NumElideArgs << " * ...]";
}
void PrintQualifiers(Qualifiers FromQual, Qualifiers ToQual) {
if (FromQual.empty() && ToQual.empty())
return;
if (FromQual == ToQual) {
PrintQualifier(FromQual, false);
return;
}
Qualifiers CommonQual = Qualifiers::removeCommonQualifiers(FromQual,
ToQual);
if (PrintTree) {
OS << "[";
if (CommonQual.empty() && FromQual.empty()) {
Bold();
OS << "(no qualifiers) ";
Unbold();
} else {
PrintQualifier(CommonQual, false);
PrintQualifier(FromQual, true);
}
OS << "!= ";
if (CommonQual.empty() && ToQual.empty()) {
Bold();
OS << "(no qualifiers)";
Unbold();
} else {
PrintQualifier(CommonQual, false,
!ToQual.empty());
PrintQualifier(ToQual, true,
false);
}
OS << "] ";
} else {
PrintQualifier(CommonQual, false);
PrintQualifier(FromQual, true);
}
}
void PrintQualifier(Qualifiers Q, bool ApplyBold,
bool AppendSpaceIfNonEmpty = true) {
if (Q.empty()) return;
if (ApplyBold) Bold();
Q.print(OS, Policy, AppendSpaceIfNonEmpty);
if (ApplyBold) Unbold();
}
public:
TemplateDiff(ASTContext &Context, QualType FromType, QualType ToType,
bool PrintTree, bool PrintFromType, bool ElideType,
bool ShowColor)
: Context(Context),
Policy(Context.getLangOpts()),
ElideType(ElideType),
PrintTree(PrintTree),
ShowColor(ShowColor),
FromType(PrintFromType ? FromType : ToType),
ToType(PrintFromType ? ToType : FromType),
OS(Str),
IsBold(false) {
}
void DiffTemplate() {
Qualifiers FromQual = FromType.getQualifiers(),
ToQual = ToType.getQualifiers();
const TemplateSpecializationType *FromOrigTST =
GetTemplateSpecializationType(Context, FromType);
const TemplateSpecializationType *ToOrigTST =
GetTemplateSpecializationType(Context, ToType);
if (!FromOrigTST || !ToOrigTST)
return;
if (!hasSameTemplate(FromOrigTST, ToOrigTST)) {
return;
}
FromQual -= QualType(FromOrigTST, 0).getQualifiers();
ToQual -= QualType(ToOrigTST, 0).getQualifiers();
Tree.SetNode(FromType, ToType);
Tree.SetNode(FromQual, ToQual);
Tree.SetNode(FromOrigTST->getTemplateName().getAsTemplateDecl(),
ToOrigTST->getTemplateName().getAsTemplateDecl());
DiffTemplate(FromOrigTST, ToOrigTST);
}
bool MakeString(std::string &S) {
Tree.StartTraverse();
if (Tree.Empty())
return false;
TreeToString();
assert(!IsBold && "Bold is applied to end of string.");
S = OS.str();
return true;
}
}; }
static bool FormatTemplateTypeDiff(ASTContext &Context, QualType FromType,
QualType ToType, bool PrintTree,
bool PrintFromType, bool ElideType,
bool ShowColors, std::string &S) {
if (PrintTree)
PrintFromType = true;
TemplateDiff TD(Context, FromType, ToType, PrintTree, PrintFromType,
ElideType, ShowColors);
TD.DiffTemplate();
return TD.MakeString(S);
}