forked from OSchip/llvm-project
2091 lines
76 KiB
C++
2091 lines
76 KiB
C++
//===--- ASTDiagnostic.cpp - Diagnostic Printing Hooks for AST Nodes ------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements a diagnostic formatting hook for AST elements.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "clang/AST/ASTDiagnostic.h"
|
|
#include "clang/AST/ASTContext.h"
|
|
#include "clang/AST/ASTLambda.h"
|
|
#include "clang/AST/Attr.h"
|
|
#include "clang/AST/DeclObjC.h"
|
|
#include "clang/AST/DeclTemplate.h"
|
|
#include "clang/AST/ExprCXX.h"
|
|
#include "clang/AST/TemplateBase.h"
|
|
#include "clang/AST/Type.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
|
|
using namespace clang;
|
|
|
|
// Returns a desugared version of the QualType, and marks ShouldAKA as true
|
|
// whenever we remove significant sugar from the type.
|
|
static QualType Desugar(ASTContext &Context, QualType QT, bool &ShouldAKA) {
|
|
QualifierCollector QC;
|
|
|
|
while (true) {
|
|
const Type *Ty = QC.strip(QT);
|
|
|
|
// Don't aka just because we saw an elaborated type...
|
|
if (const ElaboratedType *ET = dyn_cast<ElaboratedType>(Ty)) {
|
|
QT = ET->desugar();
|
|
continue;
|
|
}
|
|
// ... or a paren type ...
|
|
if (const ParenType *PT = dyn_cast<ParenType>(Ty)) {
|
|
QT = PT->desugar();
|
|
continue;
|
|
}
|
|
// ... or a macro defined type ...
|
|
if (const MacroQualifiedType *MDT = dyn_cast<MacroQualifiedType>(Ty)) {
|
|
QT = MDT->desugar();
|
|
continue;
|
|
}
|
|
// ...or a substituted template type parameter ...
|
|
if (const SubstTemplateTypeParmType *ST =
|
|
dyn_cast<SubstTemplateTypeParmType>(Ty)) {
|
|
QT = ST->desugar();
|
|
continue;
|
|
}
|
|
// ...or an attributed type...
|
|
if (const AttributedType *AT = dyn_cast<AttributedType>(Ty)) {
|
|
QT = AT->desugar();
|
|
continue;
|
|
}
|
|
// ...or an adjusted type...
|
|
if (const AdjustedType *AT = dyn_cast<AdjustedType>(Ty)) {
|
|
QT = AT->desugar();
|
|
continue;
|
|
}
|
|
// ... or an auto type.
|
|
if (const AutoType *AT = dyn_cast<AutoType>(Ty)) {
|
|
if (!AT->isSugared())
|
|
break;
|
|
QT = AT->desugar();
|
|
continue;
|
|
}
|
|
|
|
// Desugar FunctionType if return type or any parameter type should be
|
|
// desugared. Preserve nullability attribute on desugared types.
|
|
if (const FunctionType *FT = dyn_cast<FunctionType>(Ty)) {
|
|
bool DesugarReturn = false;
|
|
QualType SugarRT = FT->getReturnType();
|
|
QualType RT = Desugar(Context, SugarRT, DesugarReturn);
|
|
if (auto nullability = AttributedType::stripOuterNullability(SugarRT)) {
|
|
RT = Context.getAttributedType(
|
|
AttributedType::getNullabilityAttrKind(*nullability), RT, RT);
|
|
}
|
|
|
|
bool DesugarArgument = false;
|
|
SmallVector<QualType, 4> Args;
|
|
const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(FT);
|
|
if (FPT) {
|
|
for (QualType SugarPT : FPT->param_types()) {
|
|
QualType PT = Desugar(Context, SugarPT, DesugarArgument);
|
|
if (auto nullability =
|
|
AttributedType::stripOuterNullability(SugarPT)) {
|
|
PT = Context.getAttributedType(
|
|
AttributedType::getNullabilityAttrKind(*nullability), PT, PT);
|
|
}
|
|
Args.push_back(PT);
|
|
}
|
|
}
|
|
|
|
if (DesugarReturn || DesugarArgument) {
|
|
ShouldAKA = true;
|
|
QT = FPT ? Context.getFunctionType(RT, Args, FPT->getExtProtoInfo())
|
|
: Context.getFunctionNoProtoType(RT, FT->getExtInfo());
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Desugar template specializations if any template argument should be
|
|
// desugared.
|
|
if (const TemplateSpecializationType *TST =
|
|
dyn_cast<TemplateSpecializationType>(Ty)) {
|
|
if (!TST->isTypeAlias()) {
|
|
bool DesugarArgument = false;
|
|
SmallVector<TemplateArgument, 4> Args;
|
|
for (unsigned I = 0, N = TST->getNumArgs(); I != N; ++I) {
|
|
const TemplateArgument &Arg = TST->getArg(I);
|
|
if (Arg.getKind() == TemplateArgument::Type)
|
|
Args.push_back(Desugar(Context, Arg.getAsType(), DesugarArgument));
|
|
else
|
|
Args.push_back(Arg);
|
|
}
|
|
|
|
if (DesugarArgument) {
|
|
ShouldAKA = true;
|
|
QT = Context.getTemplateSpecializationType(
|
|
TST->getTemplateName(), Args, QT);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Don't desugar magic Objective-C types.
|
|
if (QualType(Ty,0) == Context.getObjCIdType() ||
|
|
QualType(Ty,0) == Context.getObjCClassType() ||
|
|
QualType(Ty,0) == Context.getObjCSelType() ||
|
|
QualType(Ty,0) == Context.getObjCProtoType())
|
|
break;
|
|
|
|
// Don't desugar va_list.
|
|
if (QualType(Ty, 0) == Context.getBuiltinVaListType() ||
|
|
QualType(Ty, 0) == Context.getBuiltinMSVaListType())
|
|
break;
|
|
|
|
// Otherwise, do a single-step desugar.
|
|
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.inc"
|
|
}
|
|
|
|
// If it wasn't sugared, we're done.
|
|
if (!IsSugar)
|
|
break;
|
|
|
|
// If the desugared type is a vector type, we don't want to expand
|
|
// it, it will turn into an attribute mess. People want their "vec4".
|
|
if (isa<VectorType>(Underlying))
|
|
break;
|
|
|
|
// Don't desugar through the primary typedef of an anonymous type.
|
|
if (const TagType *UTT = Underlying->getAs<TagType>())
|
|
if (const TypedefType *QTT = dyn_cast<TypedefType>(QT))
|
|
if (UTT->getDecl()->getTypedefNameForAnonDecl() == QTT->getDecl())
|
|
break;
|
|
|
|
// Record that we actually looked through an opaque type here.
|
|
ShouldAKA = true;
|
|
QT = Underlying;
|
|
}
|
|
|
|
// If we have a pointer-like type, desugar the pointee as well.
|
|
// FIXME: Handle other pointer-like types.
|
|
if (const PointerType *Ty = QT->getAs<PointerType>()) {
|
|
QT = Context.getPointerType(Desugar(Context, Ty->getPointeeType(),
|
|
ShouldAKA));
|
|
} else if (const auto *Ty = QT->getAs<ObjCObjectPointerType>()) {
|
|
QT = Context.getObjCObjectPointerType(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));
|
|
} else if (const auto *Ty = QT->getAs<ObjCObjectType>()) {
|
|
if (Ty->getBaseType().getTypePtr() != Ty && !ShouldAKA) {
|
|
QualType BaseType = Desugar(Context, Ty->getBaseType(), ShouldAKA);
|
|
QT = Context.getObjCObjectType(BaseType, Ty->getTypeArgsAsWritten(),
|
|
llvm::makeArrayRef(Ty->qual_begin(),
|
|
Ty->getNumProtocols()),
|
|
Ty->isKindOfTypeAsWritten());
|
|
}
|
|
}
|
|
|
|
return QC.apply(Context, QT);
|
|
}
|
|
|
|
/// Convert the given type to a string suitable for printing as part of
|
|
/// a diagnostic.
|
|
///
|
|
/// There are four main criteria when determining whether we should have an
|
|
/// a.k.a. clause when pretty-printing a type:
|
|
///
|
|
/// 1) Some types provide very minimal sugar that doesn't impede the
|
|
/// user's understanding --- for example, elaborated type
|
|
/// specifiers. If this is all the sugar we see, we don't want an
|
|
/// a.k.a. clause.
|
|
/// 2) Some types are technically sugared but are much more familiar
|
|
/// when seen in their sugared form --- for example, va_list,
|
|
/// vector types, and the magic Objective C types. We don't
|
|
/// want to desugar these, even if we do produce an a.k.a. clause.
|
|
/// 3) Some types may have already been desugared previously in this diagnostic.
|
|
/// if this is the case, doing another "aka" would just be clutter.
|
|
/// 4) Two different types within the same diagnostic have the same output
|
|
/// string. In this case, force an a.k.a with the desugared type when
|
|
/// doing so will provide additional information.
|
|
///
|
|
/// \param Context the context in which the type was allocated
|
|
/// \param Ty the type to print
|
|
/// \param QualTypeVals pointer values to QualTypes which are used in the
|
|
/// diagnostic message
|
|
static std::string
|
|
ConvertTypeToDiagnosticString(ASTContext &Context, QualType Ty,
|
|
ArrayRef<DiagnosticsEngine::ArgumentValue> PrevArgs,
|
|
ArrayRef<intptr_t> QualTypeVals) {
|
|
// FIXME: Playing with std::string is really slow.
|
|
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; // Same types
|
|
QualType CompareCanTy = CompareTy.getCanonicalType();
|
|
if (CompareCanTy == CanTy)
|
|
continue; // Same canonical types
|
|
std::string CompareS = CompareTy.getAsString(Context.getPrintingPolicy());
|
|
bool ShouldAKA = false;
|
|
QualType CompareDesugar = Desugar(Context, CompareTy, ShouldAKA);
|
|
std::string CompareDesugarStr =
|
|
CompareDesugar.getAsString(Context.getPrintingPolicy());
|
|
if (CompareS != S && CompareDesugarStr != S)
|
|
continue; // The type string is different than the comparison string
|
|
// and the desugared comparison string.
|
|
std::string CompareCanS =
|
|
CompareCanTy.getAsString(Context.getPrintingPolicy());
|
|
|
|
if (CompareCanS == CanS)
|
|
continue; // No new info from canonical type
|
|
|
|
ForceAKA = true;
|
|
break;
|
|
}
|
|
|
|
// Check to see if we already desugared this type in this
|
|
// diagnostic. If so, don't do it again.
|
|
bool Repeated = false;
|
|
for (unsigned i = 0, e = PrevArgs.size(); i != e; ++i) {
|
|
// TODO: Handle ak_declcontext case.
|
|
if (PrevArgs[i].first == DiagnosticsEngine::ak_qualtype) {
|
|
void *Ptr = (void*)PrevArgs[i].second;
|
|
QualType PrevTy(QualType::getFromOpaquePtr(Ptr));
|
|
if (PrevTy == Ty) {
|
|
Repeated = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Consider producing an a.k.a. clause if removing all the direct
|
|
// sugar gives us something "significantly different".
|
|
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;
|
|
}
|
|
}
|
|
|
|
// Give some additional info on vector types. These are either not desugared
|
|
// or displaying complex __attribute__ expressions so add details of the
|
|
// type and element count.
|
|
if (const auto *VTy = Ty->getAs<VectorType>()) {
|
|
std::string DecoratedString;
|
|
llvm::raw_string_ostream OS(DecoratedString);
|
|
const char *Values = VTy->getNumElements() > 1 ? "values" : "value";
|
|
OS << "'" << S << "' (vector of " << VTy->getNumElements() << " '"
|
|
<< VTy->getElementType().getAsString(Context.getPrintingPolicy())
|
|
<< "' " << Values << ")";
|
|
return OS.str();
|
|
}
|
|
}
|
|
|
|
S = "'" + S + "'";
|
|
return S;
|
|
}
|
|
|
|
static bool FormatTemplateTypeDiff(ASTContext &Context, QualType FromType,
|
|
QualType ToType, bool PrintTree,
|
|
bool PrintFromType, bool ElideType,
|
|
bool ShowColors, raw_ostream &OS);
|
|
|
|
void clang::FormatASTNodeDiagnosticArgument(
|
|
DiagnosticsEngine::ArgumentKind Kind,
|
|
intptr_t Val,
|
|
StringRef Modifier,
|
|
StringRef Argument,
|
|
ArrayRef<DiagnosticsEngine::ArgumentValue> PrevArgs,
|
|
SmallVectorImpl<char> &Output,
|
|
void *Cookie,
|
|
ArrayRef<intptr_t> QualTypeVals) {
|
|
ASTContext &Context = *static_cast<ASTContext*>(Cookie);
|
|
|
|
size_t OldEnd = Output.size();
|
|
llvm::raw_svector_ostream OS(Output);
|
|
bool NeedQuotes = true;
|
|
|
|
switch (Kind) {
|
|
default: llvm_unreachable("unknown ArgumentKind");
|
|
case DiagnosticsEngine::ak_addrspace: {
|
|
assert(Modifier.empty() && Argument.empty() &&
|
|
"Invalid modifier for Qualfiers argument");
|
|
|
|
auto S = Qualifiers::getAddrSpaceAsString(static_cast<LangAS>(Val));
|
|
if (S.empty()) {
|
|
OS << (Context.getLangOpts().OpenCL ? "default" : "generic");
|
|
OS << " address space";
|
|
} else {
|
|
OS << "address space";
|
|
OS << " '" << S << "'";
|
|
}
|
|
NeedQuotes = false;
|
|
break;
|
|
}
|
|
case DiagnosticsEngine::ak_qual: {
|
|
assert(Modifier.empty() && Argument.empty() &&
|
|
"Invalid modifier for Qualfiers argument");
|
|
|
|
Qualifiers Q(Qualifiers::fromOpaqueValue(Val));
|
|
auto S = Q.getAsString();
|
|
if (S.empty()) {
|
|
OS << "unqualified";
|
|
NeedQuotes = false;
|
|
} else {
|
|
OS << S;
|
|
}
|
|
break;
|
|
}
|
|
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, OS)) {
|
|
NeedQuotes = !TDT.PrintTree;
|
|
TDT.TemplateDiffUsed = true;
|
|
break;
|
|
}
|
|
|
|
// Don't fall-back during tree printing. The caller will handle
|
|
// this case.
|
|
if (TDT.PrintTree)
|
|
return;
|
|
|
|
// Attempting to do a template diff on non-templates. Set the variables
|
|
// and continue with regular type printing of the appropriate type.
|
|
Val = TDT.PrintFromType ? TDT.FromType : TDT.ToType;
|
|
Modifier = StringRef();
|
|
Argument = StringRef();
|
|
// Fall through
|
|
LLVM_FALLTHROUGH;
|
|
}
|
|
case DiagnosticsEngine::ak_qualtype: {
|
|
assert(Modifier.empty() && Argument.empty() &&
|
|
"Invalid modifier for QualType argument");
|
|
|
|
QualType Ty(QualType::getFromOpaquePtr(reinterpret_cast<void*>(Val)));
|
|
OS << ConvertTypeToDiagnosticString(Context, Ty, PrevArgs, QualTypeVals);
|
|
NeedQuotes = false;
|
|
break;
|
|
}
|
|
case DiagnosticsEngine::ak_declarationname: {
|
|
if (Modifier == "objcclass" && Argument.empty())
|
|
OS << '+';
|
|
else if (Modifier == "objcinstance" && Argument.empty())
|
|
OS << '-';
|
|
else
|
|
assert(Modifier.empty() && Argument.empty() &&
|
|
"Invalid modifier for DeclarationName argument");
|
|
|
|
OS << DeclarationName::getFromOpaqueInteger(Val);
|
|
break;
|
|
}
|
|
case DiagnosticsEngine::ak_nameddecl: {
|
|
bool Qualified;
|
|
if (Modifier == "q" && Argument.empty())
|
|
Qualified = true;
|
|
else {
|
|
assert(Modifier.empty() && Argument.empty() &&
|
|
"Invalid modifier for NamedDecl* argument");
|
|
Qualified = false;
|
|
}
|
|
const NamedDecl *ND = reinterpret_cast<const NamedDecl*>(Val);
|
|
ND->getNameForDiagnostic(OS, Context.getPrintingPolicy(), Qualified);
|
|
break;
|
|
}
|
|
case DiagnosticsEngine::ak_nestednamespec: {
|
|
NestedNameSpecifier *NNS = reinterpret_cast<NestedNameSpecifier*>(Val);
|
|
NNS->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");
|
|
NeedQuotes = false;
|
|
|
|
// FIXME: Get the strings for DeclContext from some localized place
|
|
if (DC->isTranslationUnit()) {
|
|
if (Context.getLangOpts().CPlusPlus)
|
|
OS << "the global namespace";
|
|
else
|
|
OS << "the global scope";
|
|
} else if (DC->isClosure()) {
|
|
OS << "block literal";
|
|
} else if (isLambdaCallOperator(DC)) {
|
|
OS << "lambda expression";
|
|
} else if (TypeDecl *Type = dyn_cast<TypeDecl>(DC)) {
|
|
OS << ConvertTypeToDiagnosticString(Context,
|
|
Context.getTypeDeclType(Type),
|
|
PrevArgs, QualTypeVals);
|
|
} else {
|
|
assert(isa<NamedDecl>(DC) && "Expected a NamedDecl");
|
|
NamedDecl *ND = cast<NamedDecl>(DC);
|
|
if (isa<NamespaceDecl>(ND))
|
|
OS << "namespace ";
|
|
else if (isa<ObjCMethodDecl>(ND))
|
|
OS << "method ";
|
|
else if (isa<FunctionDecl>(ND))
|
|
OS << "function ";
|
|
|
|
OS << '\'';
|
|
ND->getNameForDiagnostic(OS, Context.getPrintingPolicy(), true);
|
|
OS << '\'';
|
|
}
|
|
break;
|
|
}
|
|
case DiagnosticsEngine::ak_attr: {
|
|
const Attr *At = reinterpret_cast<Attr *>(Val);
|
|
assert(At && "Received null Attr object!");
|
|
OS << '\'' << At->getSpelling() << '\'';
|
|
NeedQuotes = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (NeedQuotes) {
|
|
Output.insert(Output.begin()+OldEnd, '\'');
|
|
Output.push_back('\'');
|
|
}
|
|
}
|
|
|
|
/// TemplateDiff - A class that constructs a pretty string for a pair of
|
|
/// QualTypes. For the pair of types, a diff tree will be created containing
|
|
/// all the information about the templates and template arguments. Afterwards,
|
|
/// the tree is transformed to a string according to the options passed in.
|
|
namespace {
|
|
class TemplateDiff {
|
|
/// Context - The ASTContext which is used for comparing template arguments.
|
|
ASTContext &Context;
|
|
|
|
/// Policy - Used during expression printing.
|
|
PrintingPolicy Policy;
|
|
|
|
/// ElideType - Option to elide identical types.
|
|
bool ElideType;
|
|
|
|
/// PrintTree - Format output string as a tree.
|
|
bool PrintTree;
|
|
|
|
/// ShowColor - Diagnostics support color, so bolding will be used.
|
|
bool ShowColor;
|
|
|
|
/// FromTemplateType - When single type printing is selected, this is the
|
|
/// type to be be printed. When tree printing is selected, this type will
|
|
/// show up first in the tree.
|
|
QualType FromTemplateType;
|
|
|
|
/// ToTemplateType - The type that FromType is compared to. Only in tree
|
|
/// printing will this type be outputed.
|
|
QualType ToTemplateType;
|
|
|
|
/// OS - The stream used to construct the output strings.
|
|
raw_ostream &OS;
|
|
|
|
/// IsBold - Keeps track of the bold formatting for the output string.
|
|
bool IsBold;
|
|
|
|
/// DiffTree - A tree representation the differences between two types.
|
|
class DiffTree {
|
|
public:
|
|
/// DiffKind - The difference in a DiffNode. Fields of
|
|
/// TemplateArgumentInfo needed by each difference can be found in the
|
|
/// Set* and Get* functions.
|
|
enum DiffKind {
|
|
/// Incomplete or invalid node.
|
|
Invalid,
|
|
/// Another level of templates
|
|
Template,
|
|
/// Type difference, all type differences except those falling under
|
|
/// the Template difference.
|
|
Type,
|
|
/// Expression difference, this is only when both arguments are
|
|
/// expressions. If one argument is an expression and the other is
|
|
/// Integer or Declaration, then use that diff type instead.
|
|
Expression,
|
|
/// Template argument difference
|
|
TemplateTemplate,
|
|
/// Integer difference
|
|
Integer,
|
|
/// Declaration difference, nullptr arguments are included here
|
|
Declaration,
|
|
/// One argument being integer and the other being declaration
|
|
FromIntegerAndToDeclaration,
|
|
FromDeclarationAndToInteger
|
|
};
|
|
|
|
private:
|
|
/// TemplateArgumentInfo - All the information needed to pretty print
|
|
/// a template argument. See the Set* and Get* functions to see which
|
|
/// fields are used for each DiffKind.
|
|
struct TemplateArgumentInfo {
|
|
QualType ArgType;
|
|
Qualifiers Qual;
|
|
llvm::APSInt Val;
|
|
bool IsValidInt = false;
|
|
Expr *ArgExpr = nullptr;
|
|
TemplateDecl *TD = nullptr;
|
|
ValueDecl *VD = nullptr;
|
|
bool NeedAddressOf = false;
|
|
bool IsNullPtr = false;
|
|
bool IsDefault = false;
|
|
};
|
|
|
|
/// DiffNode - The root node stores the original type. Each child node
|
|
/// stores template arguments of their parents. For templated types, the
|
|
/// template decl is also stored.
|
|
struct DiffNode {
|
|
DiffKind Kind = Invalid;
|
|
|
|
/// NextNode - The index of the next sibling node or 0.
|
|
unsigned NextNode = 0;
|
|
|
|
/// ChildNode - The index of the first child node or 0.
|
|
unsigned ChildNode = 0;
|
|
|
|
/// ParentNode - The index of the parent node.
|
|
unsigned ParentNode = 0;
|
|
|
|
TemplateArgumentInfo FromArgInfo, ToArgInfo;
|
|
|
|
/// Same - Whether the two arguments evaluate to the same value.
|
|
bool Same = false;
|
|
|
|
DiffNode(unsigned ParentNode = 0) : ParentNode(ParentNode) {}
|
|
};
|
|
|
|
/// FlatTree - A flattened tree used to store the DiffNodes.
|
|
SmallVector<DiffNode, 16> FlatTree;
|
|
|
|
/// CurrentNode - The index of the current node being used.
|
|
unsigned CurrentNode;
|
|
|
|
/// NextFreeNode - The index of the next unused node. Used when creating
|
|
/// child nodes.
|
|
unsigned NextFreeNode;
|
|
|
|
/// ReadNode - The index of the current node being read.
|
|
unsigned ReadNode;
|
|
|
|
public:
|
|
DiffTree() : CurrentNode(0), NextFreeNode(1), ReadNode(0) {
|
|
FlatTree.push_back(DiffNode());
|
|
}
|
|
|
|
// Node writing functions, one for each valid DiffKind element.
|
|
void SetTemplateDiff(TemplateDecl *FromTD, TemplateDecl *ToTD,
|
|
Qualifiers FromQual, Qualifiers ToQual,
|
|
bool FromDefault, bool ToDefault) {
|
|
assert(FlatTree[CurrentNode].Kind == Invalid && "Node is not empty.");
|
|
FlatTree[CurrentNode].Kind = Template;
|
|
FlatTree[CurrentNode].FromArgInfo.TD = FromTD;
|
|
FlatTree[CurrentNode].ToArgInfo.TD = ToTD;
|
|
FlatTree[CurrentNode].FromArgInfo.Qual = FromQual;
|
|
FlatTree[CurrentNode].ToArgInfo.Qual = ToQual;
|
|
SetDefault(FromDefault, ToDefault);
|
|
}
|
|
|
|
void SetTypeDiff(QualType FromType, QualType ToType, bool FromDefault,
|
|
bool ToDefault) {
|
|
assert(FlatTree[CurrentNode].Kind == Invalid && "Node is not empty.");
|
|
FlatTree[CurrentNode].Kind = Type;
|
|
FlatTree[CurrentNode].FromArgInfo.ArgType = FromType;
|
|
FlatTree[CurrentNode].ToArgInfo.ArgType = ToType;
|
|
SetDefault(FromDefault, ToDefault);
|
|
}
|
|
|
|
void SetExpressionDiff(Expr *FromExpr, Expr *ToExpr, bool FromDefault,
|
|
bool ToDefault) {
|
|
assert(FlatTree[CurrentNode].Kind == Invalid && "Node is not empty.");
|
|
FlatTree[CurrentNode].Kind = Expression;
|
|
FlatTree[CurrentNode].FromArgInfo.ArgExpr = FromExpr;
|
|
FlatTree[CurrentNode].ToArgInfo.ArgExpr = ToExpr;
|
|
SetDefault(FromDefault, ToDefault);
|
|
}
|
|
|
|
void SetTemplateTemplateDiff(TemplateDecl *FromTD, TemplateDecl *ToTD,
|
|
bool FromDefault, bool ToDefault) {
|
|
assert(FlatTree[CurrentNode].Kind == Invalid && "Node is not empty.");
|
|
FlatTree[CurrentNode].Kind = TemplateTemplate;
|
|
FlatTree[CurrentNode].FromArgInfo.TD = FromTD;
|
|
FlatTree[CurrentNode].ToArgInfo.TD = ToTD;
|
|
SetDefault(FromDefault, ToDefault);
|
|
}
|
|
|
|
void SetIntegerDiff(const llvm::APSInt &FromInt, const llvm::APSInt &ToInt,
|
|
bool IsValidFromInt, bool IsValidToInt,
|
|
QualType FromIntType, QualType ToIntType,
|
|
Expr *FromExpr, Expr *ToExpr, bool FromDefault,
|
|
bool ToDefault) {
|
|
assert(FlatTree[CurrentNode].Kind == Invalid && "Node is not empty.");
|
|
FlatTree[CurrentNode].Kind = Integer;
|
|
FlatTree[CurrentNode].FromArgInfo.Val = FromInt;
|
|
FlatTree[CurrentNode].ToArgInfo.Val = ToInt;
|
|
FlatTree[CurrentNode].FromArgInfo.IsValidInt = IsValidFromInt;
|
|
FlatTree[CurrentNode].ToArgInfo.IsValidInt = IsValidToInt;
|
|
FlatTree[CurrentNode].FromArgInfo.ArgType = FromIntType;
|
|
FlatTree[CurrentNode].ToArgInfo.ArgType = ToIntType;
|
|
FlatTree[CurrentNode].FromArgInfo.ArgExpr = FromExpr;
|
|
FlatTree[CurrentNode].ToArgInfo.ArgExpr = ToExpr;
|
|
SetDefault(FromDefault, ToDefault);
|
|
}
|
|
|
|
void SetDeclarationDiff(ValueDecl *FromValueDecl, ValueDecl *ToValueDecl,
|
|
bool FromAddressOf, bool ToAddressOf,
|
|
bool FromNullPtr, bool ToNullPtr, Expr *FromExpr,
|
|
Expr *ToExpr, bool FromDefault, bool ToDefault) {
|
|
assert(FlatTree[CurrentNode].Kind == Invalid && "Node is not empty.");
|
|
FlatTree[CurrentNode].Kind = Declaration;
|
|
FlatTree[CurrentNode].FromArgInfo.VD = FromValueDecl;
|
|
FlatTree[CurrentNode].ToArgInfo.VD = ToValueDecl;
|
|
FlatTree[CurrentNode].FromArgInfo.NeedAddressOf = FromAddressOf;
|
|
FlatTree[CurrentNode].ToArgInfo.NeedAddressOf = ToAddressOf;
|
|
FlatTree[CurrentNode].FromArgInfo.IsNullPtr = FromNullPtr;
|
|
FlatTree[CurrentNode].ToArgInfo.IsNullPtr = ToNullPtr;
|
|
FlatTree[CurrentNode].FromArgInfo.ArgExpr = FromExpr;
|
|
FlatTree[CurrentNode].ToArgInfo.ArgExpr = ToExpr;
|
|
SetDefault(FromDefault, ToDefault);
|
|
}
|
|
|
|
void SetFromDeclarationAndToIntegerDiff(
|
|
ValueDecl *FromValueDecl, bool FromAddressOf, bool FromNullPtr,
|
|
Expr *FromExpr, const llvm::APSInt &ToInt, bool IsValidToInt,
|
|
QualType ToIntType, Expr *ToExpr, bool FromDefault, bool ToDefault) {
|
|
assert(FlatTree[CurrentNode].Kind == Invalid && "Node is not empty.");
|
|
FlatTree[CurrentNode].Kind = FromDeclarationAndToInteger;
|
|
FlatTree[CurrentNode].FromArgInfo.VD = FromValueDecl;
|
|
FlatTree[CurrentNode].FromArgInfo.NeedAddressOf = FromAddressOf;
|
|
FlatTree[CurrentNode].FromArgInfo.IsNullPtr = FromNullPtr;
|
|
FlatTree[CurrentNode].FromArgInfo.ArgExpr = FromExpr;
|
|
FlatTree[CurrentNode].ToArgInfo.Val = ToInt;
|
|
FlatTree[CurrentNode].ToArgInfo.IsValidInt = IsValidToInt;
|
|
FlatTree[CurrentNode].ToArgInfo.ArgType = ToIntType;
|
|
FlatTree[CurrentNode].ToArgInfo.ArgExpr = ToExpr;
|
|
SetDefault(FromDefault, ToDefault);
|
|
}
|
|
|
|
void SetFromIntegerAndToDeclarationDiff(
|
|
const llvm::APSInt &FromInt, bool IsValidFromInt, QualType FromIntType,
|
|
Expr *FromExpr, ValueDecl *ToValueDecl, bool ToAddressOf,
|
|
bool ToNullPtr, Expr *ToExpr, bool FromDefault, bool ToDefault) {
|
|
assert(FlatTree[CurrentNode].Kind == Invalid && "Node is not empty.");
|
|
FlatTree[CurrentNode].Kind = FromIntegerAndToDeclaration;
|
|
FlatTree[CurrentNode].FromArgInfo.Val = FromInt;
|
|
FlatTree[CurrentNode].FromArgInfo.IsValidInt = IsValidFromInt;
|
|
FlatTree[CurrentNode].FromArgInfo.ArgType = FromIntType;
|
|
FlatTree[CurrentNode].FromArgInfo.ArgExpr = FromExpr;
|
|
FlatTree[CurrentNode].ToArgInfo.VD = ToValueDecl;
|
|
FlatTree[CurrentNode].ToArgInfo.NeedAddressOf = ToAddressOf;
|
|
FlatTree[CurrentNode].ToArgInfo.IsNullPtr = ToNullPtr;
|
|
FlatTree[CurrentNode].ToArgInfo.ArgExpr = ToExpr;
|
|
SetDefault(FromDefault, ToDefault);
|
|
}
|
|
|
|
/// SetDefault - Sets FromDefault and ToDefault flags of the current node.
|
|
void SetDefault(bool FromDefault, bool ToDefault) {
|
|
assert((!FromDefault || !ToDefault) && "Both arguments cannot be default.");
|
|
FlatTree[CurrentNode].FromArgInfo.IsDefault = FromDefault;
|
|
FlatTree[CurrentNode].ToArgInfo.IsDefault = ToDefault;
|
|
}
|
|
|
|
/// SetSame - Sets the same flag of the current node.
|
|
void SetSame(bool Same) {
|
|
FlatTree[CurrentNode].Same = Same;
|
|
}
|
|
|
|
/// SetKind - Sets the current node's type.
|
|
void SetKind(DiffKind Kind) {
|
|
FlatTree[CurrentNode].Kind = Kind;
|
|
}
|
|
|
|
/// Up - Changes the node to the parent of the current node.
|
|
void Up() {
|
|
assert(FlatTree[CurrentNode].Kind != Invalid &&
|
|
"Cannot exit node before setting node information.");
|
|
CurrentNode = FlatTree[CurrentNode].ParentNode;
|
|
}
|
|
|
|
/// AddNode - Adds a child node to the current node, then sets that node
|
|
/// node as the current node.
|
|
void AddNode() {
|
|
assert(FlatTree[CurrentNode].Kind == Template &&
|
|
"Only Template nodes can have children nodes.");
|
|
FlatTree.push_back(DiffNode(CurrentNode));
|
|
DiffNode &Node = FlatTree[CurrentNode];
|
|
if (Node.ChildNode == 0) {
|
|
// If a child node doesn't exist, add one.
|
|
Node.ChildNode = NextFreeNode;
|
|
} else {
|
|
// If a child node exists, find the last child node and add a
|
|
// next node to it.
|
|
unsigned i;
|
|
for (i = Node.ChildNode; FlatTree[i].NextNode != 0;
|
|
i = FlatTree[i].NextNode) {
|
|
}
|
|
FlatTree[i].NextNode = NextFreeNode;
|
|
}
|
|
CurrentNode = NextFreeNode;
|
|
++NextFreeNode;
|
|
}
|
|
|
|
// Node reading functions.
|
|
/// StartTraverse - Prepares the tree for recursive traversal.
|
|
void StartTraverse() {
|
|
ReadNode = 0;
|
|
CurrentNode = NextFreeNode;
|
|
NextFreeNode = 0;
|
|
}
|
|
|
|
/// Parent - Move the current read node to its parent.
|
|
void Parent() {
|
|
ReadNode = FlatTree[ReadNode].ParentNode;
|
|
}
|
|
|
|
void GetTemplateDiff(TemplateDecl *&FromTD, TemplateDecl *&ToTD,
|
|
Qualifiers &FromQual, Qualifiers &ToQual) {
|
|
assert(FlatTree[ReadNode].Kind == Template && "Unexpected kind.");
|
|
FromTD = FlatTree[ReadNode].FromArgInfo.TD;
|
|
ToTD = FlatTree[ReadNode].ToArgInfo.TD;
|
|
FromQual = FlatTree[ReadNode].FromArgInfo.Qual;
|
|
ToQual = FlatTree[ReadNode].ToArgInfo.Qual;
|
|
}
|
|
|
|
void GetTypeDiff(QualType &FromType, QualType &ToType) {
|
|
assert(FlatTree[ReadNode].Kind == Type && "Unexpected kind");
|
|
FromType = FlatTree[ReadNode].FromArgInfo.ArgType;
|
|
ToType = FlatTree[ReadNode].ToArgInfo.ArgType;
|
|
}
|
|
|
|
void GetExpressionDiff(Expr *&FromExpr, Expr *&ToExpr) {
|
|
assert(FlatTree[ReadNode].Kind == Expression && "Unexpected kind");
|
|
FromExpr = FlatTree[ReadNode].FromArgInfo.ArgExpr;
|
|
ToExpr = FlatTree[ReadNode].ToArgInfo.ArgExpr;
|
|
}
|
|
|
|
void GetTemplateTemplateDiff(TemplateDecl *&FromTD, TemplateDecl *&ToTD) {
|
|
assert(FlatTree[ReadNode].Kind == TemplateTemplate && "Unexpected kind.");
|
|
FromTD = FlatTree[ReadNode].FromArgInfo.TD;
|
|
ToTD = FlatTree[ReadNode].ToArgInfo.TD;
|
|
}
|
|
|
|
void GetIntegerDiff(llvm::APSInt &FromInt, llvm::APSInt &ToInt,
|
|
bool &IsValidFromInt, bool &IsValidToInt,
|
|
QualType &FromIntType, QualType &ToIntType,
|
|
Expr *&FromExpr, Expr *&ToExpr) {
|
|
assert(FlatTree[ReadNode].Kind == Integer && "Unexpected kind.");
|
|
FromInt = FlatTree[ReadNode].FromArgInfo.Val;
|
|
ToInt = FlatTree[ReadNode].ToArgInfo.Val;
|
|
IsValidFromInt = FlatTree[ReadNode].FromArgInfo.IsValidInt;
|
|
IsValidToInt = FlatTree[ReadNode].ToArgInfo.IsValidInt;
|
|
FromIntType = FlatTree[ReadNode].FromArgInfo.ArgType;
|
|
ToIntType = FlatTree[ReadNode].ToArgInfo.ArgType;
|
|
FromExpr = FlatTree[ReadNode].FromArgInfo.ArgExpr;
|
|
ToExpr = FlatTree[ReadNode].ToArgInfo.ArgExpr;
|
|
}
|
|
|
|
void GetDeclarationDiff(ValueDecl *&FromValueDecl, ValueDecl *&ToValueDecl,
|
|
bool &FromAddressOf, bool &ToAddressOf,
|
|
bool &FromNullPtr, bool &ToNullPtr, Expr *&FromExpr,
|
|
Expr *&ToExpr) {
|
|
assert(FlatTree[ReadNode].Kind == Declaration && "Unexpected kind.");
|
|
FromValueDecl = FlatTree[ReadNode].FromArgInfo.VD;
|
|
ToValueDecl = FlatTree[ReadNode].ToArgInfo.VD;
|
|
FromAddressOf = FlatTree[ReadNode].FromArgInfo.NeedAddressOf;
|
|
ToAddressOf = FlatTree[ReadNode].ToArgInfo.NeedAddressOf;
|
|
FromNullPtr = FlatTree[ReadNode].FromArgInfo.IsNullPtr;
|
|
ToNullPtr = FlatTree[ReadNode].ToArgInfo.IsNullPtr;
|
|
FromExpr = FlatTree[ReadNode].FromArgInfo.ArgExpr;
|
|
ToExpr = FlatTree[ReadNode].ToArgInfo.ArgExpr;
|
|
}
|
|
|
|
void GetFromDeclarationAndToIntegerDiff(
|
|
ValueDecl *&FromValueDecl, bool &FromAddressOf, bool &FromNullPtr,
|
|
Expr *&FromExpr, llvm::APSInt &ToInt, bool &IsValidToInt,
|
|
QualType &ToIntType, Expr *&ToExpr) {
|
|
assert(FlatTree[ReadNode].Kind == FromDeclarationAndToInteger &&
|
|
"Unexpected kind.");
|
|
FromValueDecl = FlatTree[ReadNode].FromArgInfo.VD;
|
|
FromAddressOf = FlatTree[ReadNode].FromArgInfo.NeedAddressOf;
|
|
FromNullPtr = FlatTree[ReadNode].FromArgInfo.IsNullPtr;
|
|
FromExpr = FlatTree[ReadNode].FromArgInfo.ArgExpr;
|
|
ToInt = FlatTree[ReadNode].ToArgInfo.Val;
|
|
IsValidToInt = FlatTree[ReadNode].ToArgInfo.IsValidInt;
|
|
ToIntType = FlatTree[ReadNode].ToArgInfo.ArgType;
|
|
ToExpr = FlatTree[ReadNode].ToArgInfo.ArgExpr;
|
|
}
|
|
|
|
void GetFromIntegerAndToDeclarationDiff(
|
|
llvm::APSInt &FromInt, bool &IsValidFromInt, QualType &FromIntType,
|
|
Expr *&FromExpr, ValueDecl *&ToValueDecl, bool &ToAddressOf,
|
|
bool &ToNullPtr, Expr *&ToExpr) {
|
|
assert(FlatTree[ReadNode].Kind == FromIntegerAndToDeclaration &&
|
|
"Unexpected kind.");
|
|
FromInt = FlatTree[ReadNode].FromArgInfo.Val;
|
|
IsValidFromInt = FlatTree[ReadNode].FromArgInfo.IsValidInt;
|
|
FromIntType = FlatTree[ReadNode].FromArgInfo.ArgType;
|
|
FromExpr = FlatTree[ReadNode].FromArgInfo.ArgExpr;
|
|
ToValueDecl = FlatTree[ReadNode].ToArgInfo.VD;
|
|
ToAddressOf = FlatTree[ReadNode].ToArgInfo.NeedAddressOf;
|
|
ToNullPtr = FlatTree[ReadNode].ToArgInfo.IsNullPtr;
|
|
ToExpr = FlatTree[ReadNode].ToArgInfo.ArgExpr;
|
|
}
|
|
|
|
/// FromDefault - Return true if the from argument is the default.
|
|
bool FromDefault() {
|
|
return FlatTree[ReadNode].FromArgInfo.IsDefault;
|
|
}
|
|
|
|
/// ToDefault - Return true if the to argument is the default.
|
|
bool ToDefault() {
|
|
return FlatTree[ReadNode].ToArgInfo.IsDefault;
|
|
}
|
|
|
|
/// NodeIsSame - Returns true the arguments are the same.
|
|
bool NodeIsSame() {
|
|
return FlatTree[ReadNode].Same;
|
|
}
|
|
|
|
/// HasChildrend - Returns true if the node has children.
|
|
bool HasChildren() {
|
|
return FlatTree[ReadNode].ChildNode != 0;
|
|
}
|
|
|
|
/// MoveToChild - Moves from the current node to its child.
|
|
void MoveToChild() {
|
|
ReadNode = FlatTree[ReadNode].ChildNode;
|
|
}
|
|
|
|
/// AdvanceSibling - If there is a next sibling, advance to it and return
|
|
/// true. Otherwise, return false.
|
|
bool AdvanceSibling() {
|
|
if (FlatTree[ReadNode].NextNode == 0)
|
|
return false;
|
|
|
|
ReadNode = FlatTree[ReadNode].NextNode;
|
|
return true;
|
|
}
|
|
|
|
/// HasNextSibling - Return true if the node has a next sibling.
|
|
bool HasNextSibling() {
|
|
return FlatTree[ReadNode].NextNode != 0;
|
|
}
|
|
|
|
/// Empty - Returns true if the tree has no information.
|
|
bool Empty() {
|
|
return GetKind() == Invalid;
|
|
}
|
|
|
|
/// GetKind - Returns the current node's type.
|
|
DiffKind GetKind() {
|
|
return FlatTree[ReadNode].Kind;
|
|
}
|
|
};
|
|
|
|
DiffTree Tree;
|
|
|
|
/// TSTiterator - a pair of iterators that walks the
|
|
/// TemplateSpecializationType and the desugared TemplateSpecializationType.
|
|
/// The deseguared TemplateArgument should provide the canonical argument
|
|
/// for comparisons.
|
|
class TSTiterator {
|
|
typedef const TemplateArgument& reference;
|
|
typedef const TemplateArgument* pointer;
|
|
|
|
/// InternalIterator - an iterator that is used to enter a
|
|
/// TemplateSpecializationType and read TemplateArguments inside template
|
|
/// parameter packs in order with the rest of the TemplateArguments.
|
|
struct InternalIterator {
|
|
/// TST - the template specialization whose arguments this iterator
|
|
/// traverse over.
|
|
const TemplateSpecializationType *TST;
|
|
|
|
/// Index - the index of the template argument in TST.
|
|
unsigned Index;
|
|
|
|
/// CurrentTA - if CurrentTA is not the same as EndTA, then CurrentTA
|
|
/// points to a TemplateArgument within a parameter pack.
|
|
TemplateArgument::pack_iterator CurrentTA;
|
|
|
|
/// EndTA - the end iterator of a parameter pack
|
|
TemplateArgument::pack_iterator EndTA;
|
|
|
|
/// InternalIterator - Constructs an iterator and sets it to the first
|
|
/// template argument.
|
|
InternalIterator(const TemplateSpecializationType *TST)
|
|
: TST(TST), Index(0), CurrentTA(nullptr), EndTA(nullptr) {
|
|
if (!TST) return;
|
|
|
|
if (isEnd()) return;
|
|
|
|
// Set to first template argument. If not a parameter pack, done.
|
|
TemplateArgument TA = TST->getArg(0);
|
|
if (TA.getKind() != TemplateArgument::Pack) return;
|
|
|
|
// Start looking into the parameter pack.
|
|
CurrentTA = TA.pack_begin();
|
|
EndTA = TA.pack_end();
|
|
|
|
// Found a valid template argument.
|
|
if (CurrentTA != EndTA) return;
|
|
|
|
// Parameter pack is empty, use the increment to get to a valid
|
|
// template argument.
|
|
++(*this);
|
|
}
|
|
|
|
/// Return true if the iterator is non-singular.
|
|
bool isValid() const { return TST; }
|
|
|
|
/// isEnd - Returns true if the iterator is one past the end.
|
|
bool isEnd() const {
|
|
assert(TST && "InternalIterator is invalid with a null TST.");
|
|
return Index >= TST->getNumArgs();
|
|
}
|
|
|
|
/// &operator++ - Increment the iterator to the next template argument.
|
|
InternalIterator &operator++() {
|
|
assert(TST && "InternalIterator is invalid with a null TST.");
|
|
if (isEnd()) {
|
|
return *this;
|
|
}
|
|
|
|
// If in a parameter pack, advance in the parameter pack.
|
|
if (CurrentTA != EndTA) {
|
|
++CurrentTA;
|
|
if (CurrentTA != EndTA)
|
|
return *this;
|
|
}
|
|
|
|
// Loop until a template argument is found, or the end is reached.
|
|
while (true) {
|
|
// Advance to the next template argument. Break if reached the end.
|
|
if (++Index == TST->getNumArgs())
|
|
break;
|
|
|
|
// If the TemplateArgument is not a parameter pack, done.
|
|
TemplateArgument TA = TST->getArg(Index);
|
|
if (TA.getKind() != TemplateArgument::Pack)
|
|
break;
|
|
|
|
// Handle parameter packs.
|
|
CurrentTA = TA.pack_begin();
|
|
EndTA = TA.pack_end();
|
|
|
|
// If the parameter pack is empty, try to advance again.
|
|
if (CurrentTA != EndTA)
|
|
break;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
/// operator* - Returns the appropriate TemplateArgument.
|
|
reference operator*() const {
|
|
assert(TST && "InternalIterator is invalid with a null TST.");
|
|
assert(!isEnd() && "Index exceeds number of arguments.");
|
|
if (CurrentTA == EndTA)
|
|
return TST->getArg(Index);
|
|
else
|
|
return *CurrentTA;
|
|
}
|
|
|
|
/// operator-> - Allow access to the underlying TemplateArgument.
|
|
pointer operator->() const {
|
|
assert(TST && "InternalIterator is invalid with a null TST.");
|
|
return &operator*();
|
|
}
|
|
};
|
|
|
|
InternalIterator SugaredIterator;
|
|
InternalIterator DesugaredIterator;
|
|
|
|
public:
|
|
TSTiterator(ASTContext &Context, const TemplateSpecializationType *TST)
|
|
: SugaredIterator(TST),
|
|
DesugaredIterator(
|
|
(TST->isSugared() && !TST->isTypeAlias())
|
|
? GetTemplateSpecializationType(Context, TST->desugar())
|
|
: nullptr) {}
|
|
|
|
/// &operator++ - Increment the iterator to the next template argument.
|
|
TSTiterator &operator++() {
|
|
++SugaredIterator;
|
|
if (DesugaredIterator.isValid())
|
|
++DesugaredIterator;
|
|
return *this;
|
|
}
|
|
|
|
/// operator* - Returns the appropriate TemplateArgument.
|
|
reference operator*() const {
|
|
return *SugaredIterator;
|
|
}
|
|
|
|
/// operator-> - Allow access to the underlying TemplateArgument.
|
|
pointer operator->() const {
|
|
return &operator*();
|
|
}
|
|
|
|
/// isEnd - Returns true if no more TemplateArguments are available.
|
|
bool isEnd() const {
|
|
return SugaredIterator.isEnd();
|
|
}
|
|
|
|
/// hasDesugaredTA - Returns true if there is another TemplateArgument
|
|
/// available.
|
|
bool hasDesugaredTA() const {
|
|
return DesugaredIterator.isValid() && !DesugaredIterator.isEnd();
|
|
}
|
|
|
|
/// getDesugaredTA - Returns the desugared TemplateArgument.
|
|
reference getDesugaredTA() const {
|
|
assert(DesugaredIterator.isValid() &&
|
|
"Desugared TemplateArgument should not be used.");
|
|
return *DesugaredIterator;
|
|
}
|
|
};
|
|
|
|
// These functions build up the template diff tree, including functions to
|
|
// retrieve and compare template arguments.
|
|
|
|
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 nullptr;
|
|
|
|
const ClassTemplateSpecializationDecl *CTSD =
|
|
dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl());
|
|
|
|
if (!CTSD)
|
|
return nullptr;
|
|
|
|
Ty = Context.getTemplateSpecializationType(
|
|
TemplateName(CTSD->getSpecializedTemplate()),
|
|
CTSD->getTemplateArgs().asArray(),
|
|
Ty.getLocalUnqualifiedType().getCanonicalType());
|
|
|
|
return Ty->getAs<TemplateSpecializationType>();
|
|
}
|
|
|
|
/// Returns true if the DiffType is Type and false for Template.
|
|
static bool OnlyPerformTypeDiff(ASTContext &Context, QualType FromType,
|
|
QualType ToType,
|
|
const TemplateSpecializationType *&FromArgTST,
|
|
const TemplateSpecializationType *&ToArgTST) {
|
|
if (FromType.isNull() || ToType.isNull())
|
|
return true;
|
|
|
|
if (Context.hasSameType(FromType, ToType))
|
|
return true;
|
|
|
|
FromArgTST = GetTemplateSpecializationType(Context, FromType);
|
|
ToArgTST = GetTemplateSpecializationType(Context, ToType);
|
|
|
|
if (!FromArgTST || !ToArgTST)
|
|
return true;
|
|
|
|
if (!hasSameTemplate(FromArgTST, ToArgTST))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
/// DiffTypes - Fills a DiffNode with information about a type difference.
|
|
void DiffTypes(const TSTiterator &FromIter, const TSTiterator &ToIter) {
|
|
QualType FromType = GetType(FromIter);
|
|
QualType ToType = GetType(ToIter);
|
|
|
|
bool FromDefault = FromIter.isEnd() && !FromType.isNull();
|
|
bool ToDefault = ToIter.isEnd() && !ToType.isNull();
|
|
|
|
const TemplateSpecializationType *FromArgTST = nullptr;
|
|
const TemplateSpecializationType *ToArgTST = nullptr;
|
|
if (OnlyPerformTypeDiff(Context, FromType, ToType, FromArgTST, ToArgTST)) {
|
|
Tree.SetTypeDiff(FromType, ToType, FromDefault, ToDefault);
|
|
Tree.SetSame(!FromType.isNull() && !ToType.isNull() &&
|
|
Context.hasSameType(FromType, ToType));
|
|
} else {
|
|
assert(FromArgTST && ToArgTST &&
|
|
"Both template specializations need to be valid.");
|
|
Qualifiers FromQual = FromType.getQualifiers(),
|
|
ToQual = ToType.getQualifiers();
|
|
FromQual -= QualType(FromArgTST, 0).getQualifiers();
|
|
ToQual -= QualType(ToArgTST, 0).getQualifiers();
|
|
Tree.SetTemplateDiff(FromArgTST->getTemplateName().getAsTemplateDecl(),
|
|
ToArgTST->getTemplateName().getAsTemplateDecl(),
|
|
FromQual, ToQual, FromDefault, ToDefault);
|
|
DiffTemplate(FromArgTST, ToArgTST);
|
|
}
|
|
}
|
|
|
|
/// DiffTemplateTemplates - Fills a DiffNode with information about a
|
|
/// template template difference.
|
|
void DiffTemplateTemplates(const TSTiterator &FromIter,
|
|
const TSTiterator &ToIter) {
|
|
TemplateDecl *FromDecl = GetTemplateDecl(FromIter);
|
|
TemplateDecl *ToDecl = GetTemplateDecl(ToIter);
|
|
Tree.SetTemplateTemplateDiff(FromDecl, ToDecl, FromIter.isEnd() && FromDecl,
|
|
ToIter.isEnd() && ToDecl);
|
|
Tree.SetSame(FromDecl && ToDecl &&
|
|
FromDecl->getCanonicalDecl() == ToDecl->getCanonicalDecl());
|
|
}
|
|
|
|
/// InitializeNonTypeDiffVariables - Helper function for DiffNonTypes
|
|
static void InitializeNonTypeDiffVariables(ASTContext &Context,
|
|
const TSTiterator &Iter,
|
|
NonTypeTemplateParmDecl *Default,
|
|
llvm::APSInt &Value, bool &HasInt,
|
|
QualType &IntType, bool &IsNullPtr,
|
|
Expr *&E, ValueDecl *&VD,
|
|
bool &NeedAddressOf) {
|
|
if (!Iter.isEnd()) {
|
|
switch (Iter->getKind()) {
|
|
default:
|
|
llvm_unreachable("unknown ArgumentKind");
|
|
case TemplateArgument::Integral:
|
|
Value = Iter->getAsIntegral();
|
|
HasInt = true;
|
|
IntType = Iter->getIntegralType();
|
|
return;
|
|
case TemplateArgument::Declaration: {
|
|
VD = Iter->getAsDecl();
|
|
QualType ArgType = Iter->getParamTypeForDecl();
|
|
QualType VDType = VD->getType();
|
|
if (ArgType->isPointerType() &&
|
|
Context.hasSameType(ArgType->getPointeeType(), VDType))
|
|
NeedAddressOf = true;
|
|
return;
|
|
}
|
|
case TemplateArgument::NullPtr:
|
|
IsNullPtr = true;
|
|
return;
|
|
case TemplateArgument::Expression:
|
|
E = Iter->getAsExpr();
|
|
}
|
|
} else if (!Default->isParameterPack()) {
|
|
E = Default->getDefaultArgument();
|
|
}
|
|
|
|
if (!Iter.hasDesugaredTA()) return;
|
|
|
|
const TemplateArgument& TA = Iter.getDesugaredTA();
|
|
switch (TA.getKind()) {
|
|
default:
|
|
llvm_unreachable("unknown ArgumentKind");
|
|
case TemplateArgument::Integral:
|
|
Value = TA.getAsIntegral();
|
|
HasInt = true;
|
|
IntType = TA.getIntegralType();
|
|
return;
|
|
case TemplateArgument::Declaration: {
|
|
VD = TA.getAsDecl();
|
|
QualType ArgType = TA.getParamTypeForDecl();
|
|
QualType VDType = VD->getType();
|
|
if (ArgType->isPointerType() &&
|
|
Context.hasSameType(ArgType->getPointeeType(), VDType))
|
|
NeedAddressOf = true;
|
|
return;
|
|
}
|
|
case TemplateArgument::NullPtr:
|
|
IsNullPtr = true;
|
|
return;
|
|
case TemplateArgument::Expression:
|
|
// TODO: Sometimes, the desugared template argument Expr differs from
|
|
// the sugared template argument Expr. It may be useful in the future
|
|
// but for now, it is just discarded.
|
|
if (!E)
|
|
E = TA.getAsExpr();
|
|
return;
|
|
}
|
|
}
|
|
|
|
/// DiffNonTypes - Handles any template parameters not handled by DiffTypes
|
|
/// of DiffTemplatesTemplates, such as integer and declaration parameters.
|
|
void DiffNonTypes(const TSTiterator &FromIter, const TSTiterator &ToIter,
|
|
NonTypeTemplateParmDecl *FromDefaultNonTypeDecl,
|
|
NonTypeTemplateParmDecl *ToDefaultNonTypeDecl) {
|
|
Expr *FromExpr = nullptr, *ToExpr = nullptr;
|
|
llvm::APSInt FromInt, ToInt;
|
|
QualType FromIntType, ToIntType;
|
|
ValueDecl *FromValueDecl = nullptr, *ToValueDecl = nullptr;
|
|
bool HasFromInt = false, HasToInt = false, FromNullPtr = false,
|
|
ToNullPtr = false, NeedFromAddressOf = false, NeedToAddressOf = false;
|
|
InitializeNonTypeDiffVariables(
|
|
Context, FromIter, FromDefaultNonTypeDecl, FromInt, HasFromInt,
|
|
FromIntType, FromNullPtr, FromExpr, FromValueDecl, NeedFromAddressOf);
|
|
InitializeNonTypeDiffVariables(Context, ToIter, ToDefaultNonTypeDecl, ToInt,
|
|
HasToInt, ToIntType, ToNullPtr, ToExpr,
|
|
ToValueDecl, NeedToAddressOf);
|
|
|
|
bool FromDefault = FromIter.isEnd() &&
|
|
(FromExpr || FromValueDecl || HasFromInt || FromNullPtr);
|
|
bool ToDefault = ToIter.isEnd() &&
|
|
(ToExpr || ToValueDecl || HasToInt || ToNullPtr);
|
|
|
|
bool FromDeclaration = FromValueDecl || FromNullPtr;
|
|
bool ToDeclaration = ToValueDecl || ToNullPtr;
|
|
|
|
if (FromDeclaration && HasToInt) {
|
|
Tree.SetFromDeclarationAndToIntegerDiff(
|
|
FromValueDecl, NeedFromAddressOf, FromNullPtr, FromExpr, ToInt,
|
|
HasToInt, ToIntType, ToExpr, FromDefault, ToDefault);
|
|
Tree.SetSame(false);
|
|
return;
|
|
|
|
}
|
|
|
|
if (HasFromInt && ToDeclaration) {
|
|
Tree.SetFromIntegerAndToDeclarationDiff(
|
|
FromInt, HasFromInt, FromIntType, FromExpr, ToValueDecl,
|
|
NeedToAddressOf, ToNullPtr, ToExpr, FromDefault, ToDefault);
|
|
Tree.SetSame(false);
|
|
return;
|
|
}
|
|
|
|
if (HasFromInt || HasToInt) {
|
|
Tree.SetIntegerDiff(FromInt, ToInt, HasFromInt, HasToInt, FromIntType,
|
|
ToIntType, FromExpr, ToExpr, FromDefault, ToDefault);
|
|
if (HasFromInt && HasToInt) {
|
|
Tree.SetSame(Context.hasSameType(FromIntType, ToIntType) &&
|
|
FromInt == ToInt);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (FromDeclaration || ToDeclaration) {
|
|
Tree.SetDeclarationDiff(FromValueDecl, ToValueDecl, NeedFromAddressOf,
|
|
NeedToAddressOf, FromNullPtr, ToNullPtr, FromExpr,
|
|
ToExpr, FromDefault, ToDefault);
|
|
bool BothNull = FromNullPtr && ToNullPtr;
|
|
bool SameValueDecl =
|
|
FromValueDecl && ToValueDecl &&
|
|
NeedFromAddressOf == NeedToAddressOf &&
|
|
FromValueDecl->getCanonicalDecl() == ToValueDecl->getCanonicalDecl();
|
|
Tree.SetSame(BothNull || SameValueDecl);
|
|
return;
|
|
}
|
|
|
|
assert((FromExpr || ToExpr) && "Both template arguments cannot be empty.");
|
|
Tree.SetExpressionDiff(FromExpr, ToExpr, FromDefault, ToDefault);
|
|
Tree.SetSame(IsEqualExpr(Context, FromExpr, ToExpr));
|
|
}
|
|
|
|
/// DiffTemplate - recursively visits template arguments and stores the
|
|
/// argument info into a tree.
|
|
void DiffTemplate(const TemplateSpecializationType *FromTST,
|
|
const TemplateSpecializationType *ToTST) {
|
|
// Begin descent into diffing template tree.
|
|
TemplateParameterList *ParamsFrom =
|
|
FromTST->getTemplateName().getAsTemplateDecl()->getTemplateParameters();
|
|
TemplateParameterList *ParamsTo =
|
|
ToTST->getTemplateName().getAsTemplateDecl()->getTemplateParameters();
|
|
unsigned TotalArgs = 0;
|
|
for (TSTiterator FromIter(Context, FromTST), ToIter(Context, ToTST);
|
|
!FromIter.isEnd() || !ToIter.isEnd(); ++TotalArgs) {
|
|
Tree.AddNode();
|
|
|
|
// Get the parameter at index TotalArgs. If index is larger
|
|
// than the total number of parameters, then there is an
|
|
// argument pack, so re-use the last parameter.
|
|
unsigned FromParamIndex = std::min(TotalArgs, ParamsFrom->size() - 1);
|
|
unsigned ToParamIndex = std::min(TotalArgs, ParamsTo->size() - 1);
|
|
NamedDecl *FromParamND = ParamsFrom->getParam(FromParamIndex);
|
|
NamedDecl *ToParamND = ParamsTo->getParam(ToParamIndex);
|
|
|
|
assert(FromParamND->getKind() == ToParamND->getKind() &&
|
|
"Parameter Decl are not the same kind.");
|
|
|
|
if (isa<TemplateTypeParmDecl>(FromParamND)) {
|
|
DiffTypes(FromIter, ToIter);
|
|
} else if (isa<TemplateTemplateParmDecl>(FromParamND)) {
|
|
DiffTemplateTemplates(FromIter, ToIter);
|
|
} else if (isa<NonTypeTemplateParmDecl>(FromParamND)) {
|
|
NonTypeTemplateParmDecl *FromDefaultNonTypeDecl =
|
|
cast<NonTypeTemplateParmDecl>(FromParamND);
|
|
NonTypeTemplateParmDecl *ToDefaultNonTypeDecl =
|
|
cast<NonTypeTemplateParmDecl>(ToParamND);
|
|
DiffNonTypes(FromIter, ToIter, FromDefaultNonTypeDecl,
|
|
ToDefaultNonTypeDecl);
|
|
} else {
|
|
llvm_unreachable("Unexpected Decl type.");
|
|
}
|
|
|
|
++FromIter;
|
|
++ToIter;
|
|
Tree.Up();
|
|
}
|
|
}
|
|
|
|
/// makeTemplateList - Dump every template alias into the vector.
|
|
static void makeTemplateList(
|
|
SmallVectorImpl<const TemplateSpecializationType *> &TemplateList,
|
|
const TemplateSpecializationType *TST) {
|
|
while (TST) {
|
|
TemplateList.push_back(TST);
|
|
if (!TST->isTypeAlias())
|
|
return;
|
|
TST = TST->getAliasedType()->getAs<TemplateSpecializationType>();
|
|
}
|
|
}
|
|
|
|
/// hasSameBaseTemplate - Returns true when the base templates are the same,
|
|
/// even if the template arguments are not.
|
|
static bool hasSameBaseTemplate(const TemplateSpecializationType *FromTST,
|
|
const TemplateSpecializationType *ToTST) {
|
|
return FromTST->getTemplateName().getAsTemplateDecl()->getCanonicalDecl() ==
|
|
ToTST->getTemplateName().getAsTemplateDecl()->getCanonicalDecl();
|
|
}
|
|
|
|
/// hasSameTemplate - Returns true if both types are specialized from the
|
|
/// same template declaration. If they come from different template aliases,
|
|
/// do a parallel ascension search to determine the highest template alias in
|
|
/// common and set the arguments to them.
|
|
static bool hasSameTemplate(const TemplateSpecializationType *&FromTST,
|
|
const TemplateSpecializationType *&ToTST) {
|
|
// Check the top templates if they are the same.
|
|
if (hasSameBaseTemplate(FromTST, ToTST))
|
|
return true;
|
|
|
|
// Create vectors of template aliases.
|
|
SmallVector<const TemplateSpecializationType*, 1> FromTemplateList,
|
|
ToTemplateList;
|
|
|
|
makeTemplateList(FromTemplateList, FromTST);
|
|
makeTemplateList(ToTemplateList, ToTST);
|
|
|
|
SmallVectorImpl<const TemplateSpecializationType *>::reverse_iterator
|
|
FromIter = FromTemplateList.rbegin(), FromEnd = FromTemplateList.rend(),
|
|
ToIter = ToTemplateList.rbegin(), ToEnd = ToTemplateList.rend();
|
|
|
|
// Check if the lowest template types are the same. If not, return.
|
|
if (!hasSameBaseTemplate(*FromIter, *ToIter))
|
|
return false;
|
|
|
|
// Begin searching up the template aliases. The bottom most template
|
|
// matches so move up until one pair does not match. Use the template
|
|
// right before that one.
|
|
for (; FromIter != FromEnd && ToIter != ToEnd; ++FromIter, ++ToIter) {
|
|
if (!hasSameBaseTemplate(*FromIter, *ToIter))
|
|
break;
|
|
}
|
|
|
|
FromTST = FromIter[-1];
|
|
ToTST = ToIter[-1];
|
|
|
|
return true;
|
|
}
|
|
|
|
/// GetType - Retrieves the template type arguments, including default
|
|
/// arguments.
|
|
static QualType GetType(const TSTiterator &Iter) {
|
|
if (!Iter.isEnd())
|
|
return Iter->getAsType();
|
|
if (Iter.hasDesugaredTA())
|
|
return Iter.getDesugaredTA().getAsType();
|
|
return QualType();
|
|
}
|
|
|
|
/// GetTemplateDecl - Retrieves the template template arguments, including
|
|
/// default arguments.
|
|
static TemplateDecl *GetTemplateDecl(const TSTiterator &Iter) {
|
|
if (!Iter.isEnd())
|
|
return Iter->getAsTemplate().getAsTemplateDecl();
|
|
if (Iter.hasDesugaredTA())
|
|
return Iter.getDesugaredTA().getAsTemplate().getAsTemplateDecl();
|
|
return nullptr;
|
|
}
|
|
|
|
/// IsEqualExpr - Returns true if the expressions are the same in regards to
|
|
/// template arguments. These expressions are dependent, so profile them
|
|
/// instead of trying to evaluate them.
|
|
static bool IsEqualExpr(ASTContext &Context, Expr *FromExpr, Expr *ToExpr) {
|
|
if (FromExpr == ToExpr)
|
|
return true;
|
|
|
|
if (!FromExpr || !ToExpr)
|
|
return false;
|
|
|
|
llvm::FoldingSetNodeID FromID, ToID;
|
|
FromExpr->Profile(FromID, Context, true);
|
|
ToExpr->Profile(ToID, Context, true);
|
|
return FromID == ToID;
|
|
}
|
|
|
|
// These functions converts the tree representation of the template
|
|
// differences into the internal character vector.
|
|
|
|
/// TreeToString - Converts the Tree object into a character stream which
|
|
/// will later be turned into the output string.
|
|
void TreeToString(int Indent = 1) {
|
|
if (PrintTree) {
|
|
OS << '\n';
|
|
OS.indent(2 * Indent);
|
|
++Indent;
|
|
}
|
|
|
|
// Handle cases where the difference is not templates with different
|
|
// arguments.
|
|
switch (Tree.GetKind()) {
|
|
case DiffTree::Invalid:
|
|
llvm_unreachable("Template diffing failed with bad DiffNode");
|
|
case DiffTree::Type: {
|
|
QualType FromType, ToType;
|
|
Tree.GetTypeDiff(FromType, ToType);
|
|
PrintTypeNames(FromType, ToType, Tree.FromDefault(), Tree.ToDefault(),
|
|
Tree.NodeIsSame());
|
|
return;
|
|
}
|
|
case DiffTree::Expression: {
|
|
Expr *FromExpr, *ToExpr;
|
|
Tree.GetExpressionDiff(FromExpr, ToExpr);
|
|
PrintExpr(FromExpr, ToExpr, Tree.FromDefault(), Tree.ToDefault(),
|
|
Tree.NodeIsSame());
|
|
return;
|
|
}
|
|
case DiffTree::TemplateTemplate: {
|
|
TemplateDecl *FromTD, *ToTD;
|
|
Tree.GetTemplateTemplateDiff(FromTD, ToTD);
|
|
PrintTemplateTemplate(FromTD, ToTD, Tree.FromDefault(),
|
|
Tree.ToDefault(), Tree.NodeIsSame());
|
|
return;
|
|
}
|
|
case DiffTree::Integer: {
|
|
llvm::APSInt FromInt, ToInt;
|
|
Expr *FromExpr, *ToExpr;
|
|
bool IsValidFromInt, IsValidToInt;
|
|
QualType FromIntType, ToIntType;
|
|
Tree.GetIntegerDiff(FromInt, ToInt, IsValidFromInt, IsValidToInt,
|
|
FromIntType, ToIntType, FromExpr, ToExpr);
|
|
PrintAPSInt(FromInt, ToInt, IsValidFromInt, IsValidToInt, FromIntType,
|
|
ToIntType, FromExpr, ToExpr, Tree.FromDefault(),
|
|
Tree.ToDefault(), Tree.NodeIsSame());
|
|
return;
|
|
}
|
|
case DiffTree::Declaration: {
|
|
ValueDecl *FromValueDecl, *ToValueDecl;
|
|
bool FromAddressOf, ToAddressOf;
|
|
bool FromNullPtr, ToNullPtr;
|
|
Expr *FromExpr, *ToExpr;
|
|
Tree.GetDeclarationDiff(FromValueDecl, ToValueDecl, FromAddressOf,
|
|
ToAddressOf, FromNullPtr, ToNullPtr, FromExpr,
|
|
ToExpr);
|
|
PrintValueDecl(FromValueDecl, ToValueDecl, FromAddressOf, ToAddressOf,
|
|
FromNullPtr, ToNullPtr, FromExpr, ToExpr,
|
|
Tree.FromDefault(), Tree.ToDefault(), Tree.NodeIsSame());
|
|
return;
|
|
}
|
|
case DiffTree::FromDeclarationAndToInteger: {
|
|
ValueDecl *FromValueDecl;
|
|
bool FromAddressOf;
|
|
bool FromNullPtr;
|
|
Expr *FromExpr;
|
|
llvm::APSInt ToInt;
|
|
bool IsValidToInt;
|
|
QualType ToIntType;
|
|
Expr *ToExpr;
|
|
Tree.GetFromDeclarationAndToIntegerDiff(
|
|
FromValueDecl, FromAddressOf, FromNullPtr, FromExpr, ToInt,
|
|
IsValidToInt, ToIntType, ToExpr);
|
|
assert((FromValueDecl || FromNullPtr) && IsValidToInt);
|
|
PrintValueDeclAndInteger(FromValueDecl, FromAddressOf, FromNullPtr,
|
|
FromExpr, Tree.FromDefault(), ToInt, ToIntType,
|
|
ToExpr, Tree.ToDefault());
|
|
return;
|
|
}
|
|
case DiffTree::FromIntegerAndToDeclaration: {
|
|
llvm::APSInt FromInt;
|
|
bool IsValidFromInt;
|
|
QualType FromIntType;
|
|
Expr *FromExpr;
|
|
ValueDecl *ToValueDecl;
|
|
bool ToAddressOf;
|
|
bool ToNullPtr;
|
|
Expr *ToExpr;
|
|
Tree.GetFromIntegerAndToDeclarationDiff(
|
|
FromInt, IsValidFromInt, FromIntType, FromExpr, ToValueDecl,
|
|
ToAddressOf, ToNullPtr, ToExpr);
|
|
assert(IsValidFromInt && (ToValueDecl || ToNullPtr));
|
|
PrintIntegerAndValueDecl(FromInt, FromIntType, FromExpr,
|
|
Tree.FromDefault(), ToValueDecl, ToAddressOf,
|
|
ToNullPtr, ToExpr, Tree.ToDefault());
|
|
return;
|
|
}
|
|
case DiffTree::Template: {
|
|
// Node is root of template. Recurse on children.
|
|
TemplateDecl *FromTD, *ToTD;
|
|
Qualifiers FromQual, ToQual;
|
|
Tree.GetTemplateDiff(FromTD, ToTD, FromQual, ToQual);
|
|
|
|
PrintQualifiers(FromQual, ToQual);
|
|
|
|
if (!Tree.HasChildren()) {
|
|
// If we're dealing with a template specialization with zero
|
|
// arguments, there are no children; special-case this.
|
|
OS << FromTD->getDeclName() << "<>";
|
|
return;
|
|
}
|
|
|
|
OS << FromTD->getDeclName() << '<';
|
|
Tree.MoveToChild();
|
|
unsigned NumElideArgs = 0;
|
|
bool AllArgsElided = true;
|
|
do {
|
|
if (ElideType) {
|
|
if (Tree.NodeIsSame()) {
|
|
++NumElideArgs;
|
|
continue;
|
|
}
|
|
AllArgsElided = false;
|
|
if (NumElideArgs > 0) {
|
|
PrintElideArgs(NumElideArgs, Indent);
|
|
NumElideArgs = 0;
|
|
OS << ", ";
|
|
}
|
|
}
|
|
TreeToString(Indent);
|
|
if (Tree.HasNextSibling())
|
|
OS << ", ";
|
|
} while (Tree.AdvanceSibling());
|
|
if (NumElideArgs > 0) {
|
|
if (AllArgsElided)
|
|
OS << "...";
|
|
else
|
|
PrintElideArgs(NumElideArgs, Indent);
|
|
}
|
|
|
|
Tree.Parent();
|
|
OS << ">";
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// To signal to the text printer that a certain text needs to be bolded,
|
|
// a special character is injected into the character stream which the
|
|
// text printer will later strip out.
|
|
|
|
/// Bold - Start bolding text.
|
|
void Bold() {
|
|
assert(!IsBold && "Attempting to bold text that is already bold.");
|
|
IsBold = true;
|
|
if (ShowColor)
|
|
OS << ToggleHighlight;
|
|
}
|
|
|
|
/// Unbold - Stop bolding text.
|
|
void Unbold() {
|
|
assert(IsBold && "Attempting to remove bold from unbold text.");
|
|
IsBold = false;
|
|
if (ShowColor)
|
|
OS << ToggleHighlight;
|
|
}
|
|
|
|
// Functions to print out the arguments and highlighting the difference.
|
|
|
|
/// PrintTypeNames - prints the typenames, bolding differences. Will detect
|
|
/// typenames that are the same and attempt to disambiguate them by using
|
|
/// canonical typenames.
|
|
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(Policy);
|
|
return;
|
|
}
|
|
|
|
if (!FromType.isNull() && !ToType.isNull() &&
|
|
FromType.getLocalUnqualifiedType() ==
|
|
ToType.getLocalUnqualifiedType()) {
|
|
Qualifiers FromQual = FromType.getLocalQualifiers(),
|
|
ToQual = ToType.getLocalQualifiers();
|
|
PrintQualifiers(FromQual, ToQual);
|
|
FromType.getLocalUnqualifiedType().print(OS, Policy);
|
|
return;
|
|
}
|
|
|
|
std::string FromTypeStr = FromType.isNull() ? "(no argument)"
|
|
: FromType.getAsString(Policy);
|
|
std::string ToTypeStr = ToType.isNull() ? "(no argument)"
|
|
: ToType.getAsString(Policy);
|
|
// Switch to canonical typename if it is better.
|
|
// TODO: merge this with other aka printing above.
|
|
if (FromTypeStr == ToTypeStr) {
|
|
std::string FromCanTypeStr =
|
|
FromType.getCanonicalType().getAsString(Policy);
|
|
std::string ToCanTypeStr = ToType.getCanonicalType().getAsString(Policy);
|
|
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 << "]";
|
|
}
|
|
}
|
|
|
|
/// PrintExpr - Prints out the expr template arguments, highlighting argument
|
|
/// differences.
|
|
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 << ']';
|
|
}
|
|
}
|
|
|
|
/// PrintExpr - Actual formatting and printing of expressions.
|
|
void PrintExpr(const Expr *E) {
|
|
if (E) {
|
|
E->printPretty(OS, nullptr, Policy);
|
|
return;
|
|
}
|
|
OS << "(no argument)";
|
|
}
|
|
|
|
/// PrintTemplateTemplate - Handles printing of template template arguments,
|
|
/// highlighting argument differences.
|
|
void PrintTemplateTemplate(TemplateDecl *FromTD, TemplateDecl *ToTD,
|
|
bool FromDefault, bool ToDefault, bool Same) {
|
|
assert((FromTD || ToTD) && "Only one template argument may be missing.");
|
|
|
|
std::string FromName =
|
|
std::string(FromTD ? FromTD->getName() : "(no argument)");
|
|
std::string ToName = std::string(ToTD ? ToTD->getName() : "(no argument)");
|
|
if (FromTD && ToTD && FromName == ToName) {
|
|
FromName = FromTD->getQualifiedNameAsString();
|
|
ToName = ToTD->getQualifiedNameAsString();
|
|
}
|
|
|
|
if (Same) {
|
|
OS << "template " << FromTD->getDeclName();
|
|
} else if (!PrintTree) {
|
|
OS << (FromDefault ? "(default) template " : "template ");
|
|
Bold();
|
|
OS << FromName;
|
|
Unbold();
|
|
} else {
|
|
OS << (FromDefault ? "[(default) template " : "[template ");
|
|
Bold();
|
|
OS << FromName;
|
|
Unbold();
|
|
OS << " != " << (ToDefault ? "(default) template " : "template ");
|
|
Bold();
|
|
OS << ToName;
|
|
Unbold();
|
|
OS << ']';
|
|
}
|
|
}
|
|
|
|
/// PrintAPSInt - Handles printing of integral arguments, highlighting
|
|
/// argument differences.
|
|
void PrintAPSInt(const llvm::APSInt &FromInt, const llvm::APSInt &ToInt,
|
|
bool IsValidFromInt, bool IsValidToInt, QualType FromIntType,
|
|
QualType ToIntType, Expr *FromExpr, Expr *ToExpr,
|
|
bool FromDefault, bool ToDefault, bool Same) {
|
|
assert((IsValidFromInt || IsValidToInt) &&
|
|
"Only one integral argument may be missing.");
|
|
|
|
if (Same) {
|
|
if (FromIntType->isBooleanType()) {
|
|
OS << ((FromInt == 0) ? "false" : "true");
|
|
} else {
|
|
OS << FromInt.toString(10);
|
|
}
|
|
return;
|
|
}
|
|
|
|
bool PrintType = IsValidFromInt && IsValidToInt &&
|
|
!Context.hasSameType(FromIntType, ToIntType);
|
|
|
|
if (!PrintTree) {
|
|
OS << (FromDefault ? "(default) " : "");
|
|
PrintAPSInt(FromInt, FromExpr, IsValidFromInt, FromIntType, PrintType);
|
|
} else {
|
|
OS << (FromDefault ? "[(default) " : "[");
|
|
PrintAPSInt(FromInt, FromExpr, IsValidFromInt, FromIntType, PrintType);
|
|
OS << " != " << (ToDefault ? "(default) " : "");
|
|
PrintAPSInt(ToInt, ToExpr, IsValidToInt, ToIntType, PrintType);
|
|
OS << ']';
|
|
}
|
|
}
|
|
|
|
/// PrintAPSInt - If valid, print the APSInt. If the expression is
|
|
/// gives more information, print it too.
|
|
void PrintAPSInt(const llvm::APSInt &Val, Expr *E, bool Valid,
|
|
QualType IntType, bool PrintType) {
|
|
Bold();
|
|
if (Valid) {
|
|
if (HasExtraInfo(E)) {
|
|
PrintExpr(E);
|
|
Unbold();
|
|
OS << " aka ";
|
|
Bold();
|
|
}
|
|
if (PrintType) {
|
|
Unbold();
|
|
OS << "(";
|
|
Bold();
|
|
IntType.print(OS, Context.getPrintingPolicy());
|
|
Unbold();
|
|
OS << ") ";
|
|
Bold();
|
|
}
|
|
if (IntType->isBooleanType()) {
|
|
OS << ((Val == 0) ? "false" : "true");
|
|
} else {
|
|
OS << Val.toString(10);
|
|
}
|
|
} else if (E) {
|
|
PrintExpr(E);
|
|
} else {
|
|
OS << "(no argument)";
|
|
}
|
|
Unbold();
|
|
}
|
|
|
|
/// HasExtraInfo - Returns true if E is not an integer literal, the
|
|
/// negation of an integer literal, or a boolean literal.
|
|
bool HasExtraInfo(Expr *E) {
|
|
if (!E) return false;
|
|
|
|
E = E->IgnoreImpCasts();
|
|
|
|
if (isa<IntegerLiteral>(E)) return false;
|
|
|
|
if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E))
|
|
if (UO->getOpcode() == UO_Minus)
|
|
if (isa<IntegerLiteral>(UO->getSubExpr()))
|
|
return false;
|
|
|
|
if (isa<CXXBoolLiteralExpr>(E))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
void PrintValueDecl(ValueDecl *VD, bool AddressOf, Expr *E, bool NullPtr) {
|
|
if (VD) {
|
|
if (AddressOf)
|
|
OS << "&";
|
|
else if (auto *TPO = dyn_cast<TemplateParamObjectDecl>(VD)) {
|
|
// FIXME: Diffing the APValue would be neat.
|
|
// FIXME: Suppress this and use the full name of the declaration if the
|
|
// parameter is a pointer or reference.
|
|
TPO->printAsInit(OS);
|
|
return;
|
|
}
|
|
VD->printName(OS);
|
|
return;
|
|
}
|
|
|
|
if (NullPtr) {
|
|
if (E && !isa<CXXNullPtrLiteralExpr>(E)) {
|
|
PrintExpr(E);
|
|
if (IsBold) {
|
|
Unbold();
|
|
OS << " aka ";
|
|
Bold();
|
|
} else {
|
|
OS << " aka ";
|
|
}
|
|
}
|
|
|
|
OS << "nullptr";
|
|
return;
|
|
}
|
|
|
|
OS << "(no argument)";
|
|
}
|
|
|
|
/// PrintDecl - Handles printing of Decl arguments, highlighting
|
|
/// argument differences.
|
|
void PrintValueDecl(ValueDecl *FromValueDecl, ValueDecl *ToValueDecl,
|
|
bool FromAddressOf, bool ToAddressOf, bool FromNullPtr,
|
|
bool ToNullPtr, Expr *FromExpr, Expr *ToExpr,
|
|
bool FromDefault, bool ToDefault, bool Same) {
|
|
assert((FromValueDecl || FromNullPtr || ToValueDecl || ToNullPtr) &&
|
|
"Only one Decl argument may be NULL");
|
|
|
|
if (Same) {
|
|
PrintValueDecl(FromValueDecl, FromAddressOf, FromExpr, FromNullPtr);
|
|
} else if (!PrintTree) {
|
|
OS << (FromDefault ? "(default) " : "");
|
|
Bold();
|
|
PrintValueDecl(FromValueDecl, FromAddressOf, FromExpr, FromNullPtr);
|
|
Unbold();
|
|
} else {
|
|
OS << (FromDefault ? "[(default) " : "[");
|
|
Bold();
|
|
PrintValueDecl(FromValueDecl, FromAddressOf, FromExpr, FromNullPtr);
|
|
Unbold();
|
|
OS << " != " << (ToDefault ? "(default) " : "");
|
|
Bold();
|
|
PrintValueDecl(ToValueDecl, ToAddressOf, ToExpr, ToNullPtr);
|
|
Unbold();
|
|
OS << ']';
|
|
}
|
|
}
|
|
|
|
/// PrintValueDeclAndInteger - Uses the print functions for ValueDecl and
|
|
/// APSInt to print a mixed difference.
|
|
void PrintValueDeclAndInteger(ValueDecl *VD, bool NeedAddressOf,
|
|
bool IsNullPtr, Expr *VDExpr, bool DefaultDecl,
|
|
const llvm::APSInt &Val, QualType IntType,
|
|
Expr *IntExpr, bool DefaultInt) {
|
|
if (!PrintTree) {
|
|
OS << (DefaultDecl ? "(default) " : "");
|
|
Bold();
|
|
PrintValueDecl(VD, NeedAddressOf, VDExpr, IsNullPtr);
|
|
Unbold();
|
|
} else {
|
|
OS << (DefaultDecl ? "[(default) " : "[");
|
|
Bold();
|
|
PrintValueDecl(VD, NeedAddressOf, VDExpr, IsNullPtr);
|
|
Unbold();
|
|
OS << " != " << (DefaultInt ? "(default) " : "");
|
|
PrintAPSInt(Val, IntExpr, true /*Valid*/, IntType, false /*PrintType*/);
|
|
OS << ']';
|
|
}
|
|
}
|
|
|
|
/// PrintIntegerAndValueDecl - Uses the print functions for APSInt and
|
|
/// ValueDecl to print a mixed difference.
|
|
void PrintIntegerAndValueDecl(const llvm::APSInt &Val, QualType IntType,
|
|
Expr *IntExpr, bool DefaultInt, ValueDecl *VD,
|
|
bool NeedAddressOf, bool IsNullPtr,
|
|
Expr *VDExpr, bool DefaultDecl) {
|
|
if (!PrintTree) {
|
|
OS << (DefaultInt ? "(default) " : "");
|
|
PrintAPSInt(Val, IntExpr, true /*Valid*/, IntType, false /*PrintType*/);
|
|
} else {
|
|
OS << (DefaultInt ? "[(default) " : "[");
|
|
PrintAPSInt(Val, IntExpr, true /*Valid*/, IntType, false /*PrintType*/);
|
|
OS << " != " << (DefaultDecl ? "(default) " : "");
|
|
Bold();
|
|
PrintValueDecl(VD, NeedAddressOf, VDExpr, IsNullPtr);
|
|
Unbold();
|
|
OS << ']';
|
|
}
|
|
}
|
|
|
|
// Prints the appropriate placeholder for elided template arguments.
|
|
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 << " * ...]";
|
|
}
|
|
|
|
// Prints and highlights differences in Qualifiers.
|
|
void PrintQualifiers(Qualifiers FromQual, Qualifiers ToQual) {
|
|
// Both types have no qualifiers
|
|
if (FromQual.empty() && ToQual.empty())
|
|
return;
|
|
|
|
// Both types have same qualifiers
|
|
if (FromQual == ToQual) {
|
|
PrintQualifier(FromQual, /*ApplyBold*/false);
|
|
return;
|
|
}
|
|
|
|
// Find common qualifiers and strip them from FromQual and ToQual.
|
|
Qualifiers CommonQual = Qualifiers::removeCommonQualifiers(FromQual,
|
|
ToQual);
|
|
|
|
// The qualifiers are printed before the template name.
|
|
// Inline printing:
|
|
// The common qualifiers are printed. Then, qualifiers only in this type
|
|
// are printed and highlighted. Finally, qualifiers only in the other
|
|
// type are printed and highlighted inside parentheses after "missing".
|
|
// Tree printing:
|
|
// Qualifiers are printed next to each other, inside brackets, and
|
|
// separated by "!=". The printing order is:
|
|
// common qualifiers, highlighted from qualifiers, "!=",
|
|
// common qualifiers, highlighted to qualifiers
|
|
if (PrintTree) {
|
|
OS << "[";
|
|
if (CommonQual.empty() && FromQual.empty()) {
|
|
Bold();
|
|
OS << "(no qualifiers) ";
|
|
Unbold();
|
|
} else {
|
|
PrintQualifier(CommonQual, /*ApplyBold*/false);
|
|
PrintQualifier(FromQual, /*ApplyBold*/true);
|
|
}
|
|
OS << "!= ";
|
|
if (CommonQual.empty() && ToQual.empty()) {
|
|
Bold();
|
|
OS << "(no qualifiers)";
|
|
Unbold();
|
|
} else {
|
|
PrintQualifier(CommonQual, /*ApplyBold*/false,
|
|
/*appendSpaceIfNonEmpty*/!ToQual.empty());
|
|
PrintQualifier(ToQual, /*ApplyBold*/true,
|
|
/*appendSpaceIfNonEmpty*/false);
|
|
}
|
|
OS << "] ";
|
|
} else {
|
|
PrintQualifier(CommonQual, /*ApplyBold*/false);
|
|
PrintQualifier(FromQual, /*ApplyBold*/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(raw_ostream &OS, 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),
|
|
// When printing a single type, the FromType is the one printed.
|
|
FromTemplateType(PrintFromType ? FromType : ToType),
|
|
ToTemplateType(PrintFromType ? ToType : FromType),
|
|
OS(OS),
|
|
IsBold(false) {
|
|
}
|
|
|
|
/// DiffTemplate - Start the template type diffing.
|
|
void DiffTemplate() {
|
|
Qualifiers FromQual = FromTemplateType.getQualifiers(),
|
|
ToQual = ToTemplateType.getQualifiers();
|
|
|
|
const TemplateSpecializationType *FromOrigTST =
|
|
GetTemplateSpecializationType(Context, FromTemplateType);
|
|
const TemplateSpecializationType *ToOrigTST =
|
|
GetTemplateSpecializationType(Context, ToTemplateType);
|
|
|
|
// Only checking templates.
|
|
if (!FromOrigTST || !ToOrigTST)
|
|
return;
|
|
|
|
// Different base templates.
|
|
if (!hasSameTemplate(FromOrigTST, ToOrigTST)) {
|
|
return;
|
|
}
|
|
|
|
FromQual -= QualType(FromOrigTST, 0).getQualifiers();
|
|
ToQual -= QualType(ToOrigTST, 0).getQualifiers();
|
|
|
|
// Same base template, but different arguments.
|
|
Tree.SetTemplateDiff(FromOrigTST->getTemplateName().getAsTemplateDecl(),
|
|
ToOrigTST->getTemplateName().getAsTemplateDecl(),
|
|
FromQual, ToQual, false /*FromDefault*/,
|
|
false /*ToDefault*/);
|
|
|
|
DiffTemplate(FromOrigTST, ToOrigTST);
|
|
}
|
|
|
|
/// Emit - When the two types given are templated types with the same
|
|
/// base template, a string representation of the type difference will be
|
|
/// emitted to the stream and return true. Otherwise, return false.
|
|
bool Emit() {
|
|
Tree.StartTraverse();
|
|
if (Tree.Empty())
|
|
return false;
|
|
|
|
TreeToString();
|
|
assert(!IsBold && "Bold is applied to end of string.");
|
|
return true;
|
|
}
|
|
}; // end class TemplateDiff
|
|
} // end anonymous namespace
|
|
|
|
/// FormatTemplateTypeDiff - A helper static function to start the template
|
|
/// diff and return the properly formatted string. Returns true if the diff
|
|
/// is successful.
|
|
static bool FormatTemplateTypeDiff(ASTContext &Context, QualType FromType,
|
|
QualType ToType, bool PrintTree,
|
|
bool PrintFromType, bool ElideType,
|
|
bool ShowColors, raw_ostream &OS) {
|
|
if (PrintTree)
|
|
PrintFromType = true;
|
|
TemplateDiff TD(OS, Context, FromType, ToType, PrintTree, PrintFromType,
|
|
ElideType, ShowColors);
|
|
TD.DiffTemplate();
|
|
return TD.Emit();
|
|
}
|