[cfe-commits] r159216 - in /cfe/trunk: include/clang/Basic/Diagnostic.h include/clang/Basic/DiagnosticSemaKinds.td include/clang/Driver/Options.td include/clang/Frontend/DiagnosticOptions.h lib/AST/ASTDiagnostic.cpp lib/Basic/Diagnostic.cpp lib/D
David Blaikie
dblaikie at gmail.com
Tue Jun 26 11:55:30 PDT 2012
On Tue, Jun 26, 2012 at 11:18 AM, Richard Trieu <rtrieu at google.com> wrote:
> Author: rtrieu
> Date: Tue Jun 26 13:18:47 2012
> New Revision: 159216
>
> URL: http://llvm.org/viewvc/llvm-project?rev=159216&view=rev
> Log:
> Add template type diffing to Clang. This feature will provide a better
> comparison between two templated types when they both appear in a diagnostic.
> Type elision will remove indentical template arguments, which can be disabled
> with -fno-elide-type. Cyan highlighting is applied to the differing types.
Awesome!
(just tidied up some spurious semis from this change in r159218)
>
> For more formatting, -fdiagnostic-show-template-tree will output the template
> type as an indented text tree, with differences appearing inline. Template
> tree works with or without type elision.
>
> Added:
> cfe/trunk/test/Misc/diag-template-diffing.cpp
> Modified:
> cfe/trunk/include/clang/Basic/Diagnostic.h
> cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td
> cfe/trunk/include/clang/Driver/Options.td
> cfe/trunk/include/clang/Frontend/DiagnosticOptions.h
> cfe/trunk/lib/AST/ASTDiagnostic.cpp
> cfe/trunk/lib/Basic/Diagnostic.cpp
> cfe/trunk/lib/Driver/Tools.cpp
> cfe/trunk/lib/Frontend/CompilerInvocation.cpp
> cfe/trunk/lib/Frontend/TextDiagnostic.cpp
> cfe/trunk/lib/Frontend/Warnings.cpp
> cfe/trunk/test/Misc/diag-aka-types.cpp
>
> Modified: cfe/trunk/include/clang/Basic/Diagnostic.h
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Basic/Diagnostic.h?rev=159216&r1=159215&r2=159216&view=diff
> ==============================================================================
> --- cfe/trunk/include/clang/Basic/Diagnostic.h (original)
> +++ cfe/trunk/include/clang/Basic/Diagnostic.h Tue Jun 26 13:18:47 2012
> @@ -153,7 +153,8 @@
> ak_declarationname, // DeclarationName
> ak_nameddecl, // NamedDecl *
> ak_nestednamespec, // NestedNameSpecifier *
> - ak_declcontext // DeclContext *
> + ak_declcontext, // DeclContext *
> + ak_qualtype_pair // pair<QualType, QualType>
> };
>
> /// Specifies which overload candidates to display when overload resolution
> @@ -175,6 +176,9 @@
> bool ErrorsAsFatal; // Treat errors like fatal errors.
> bool SuppressSystemWarnings; // Suppress warnings in system headers.
> bool SuppressAllDiagnostics; // Suppress all diagnostics.
> + bool ElideType; // Elide common types of templates.
> + bool PrintTemplateTree; // Print a tree when comparing templates.
> + bool ShowColors; // Color printing is enabled.
> OverloadsShown ShowOverloads; // Which overload candidates to show.
> unsigned ErrorLimit; // Cap of # errors emitted, 0 -> no limit.
> unsigned TemplateBacktraceLimit; // Cap on depth of template backtrace stack,
> @@ -438,7 +442,22 @@
> SuppressAllDiagnostics = Val;
> }
> bool getSuppressAllDiagnostics() const { return SuppressAllDiagnostics; }
> -
> +
> + /// \brief Set type eliding, to skip outputting same types occurring in
> + /// template types.
> + void setElideType(bool Val = true) { ElideType = Val; }
> + bool getElideType() { return ElideType; }
> +
> + /// \brief Set tree printing, to outputting the template difference in a
> + /// tree format.
> + void setPrintTemplateTree(bool Val = false) { PrintTemplateTree = Val; }
> + bool getPrintTemplateTree() { return PrintTemplateTree; }
> +
> + /// \brief Set color printing, so the type diffing will inject color markers
> + /// into the output.
> + void setShowColors(bool Val = false) { ShowColors = Val; }
> + bool getShowColors() { return ShowColors; }
> +
> /// \brief Specify which overload candidates to show when overload resolution
> /// fails. By default, we show all candidates.
> void setShowOverloads(OverloadsShown Val) {
> @@ -1058,7 +1077,6 @@
> return DiagObj->DiagArgumentsVal[Idx];
> }
>
> -
> /// getNumRanges - Return the number of source ranges associated with this
> /// diagnostic.
> unsigned getNumRanges() const {
> @@ -1223,6 +1241,20 @@
> }
> };
>
> +// Struct used for sending info about how a type should be printed.
> +struct TemplateDiffTypes {
> + intptr_t FromType;
> + intptr_t ToType;
> + unsigned PrintTree : 1;
> + unsigned PrintFromType : 1;
> + unsigned ElideType : 1;
> + unsigned ShowColors : 1;
> +};
> +
> +/// Special character that the diagnostic printer will use to toggle the bold
> +/// attribute. The character itself will be not be printed.
> +const char ToggleHighlight = 127;
> +
> } // end namespace clang
>
> #endif
>
> Modified: cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td?rev=159216&r1=159215&r2=159216&view=diff
> ==============================================================================
> --- cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td (original)
> +++ cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td Tue Jun 26 13:18:47 2012
> @@ -2162,7 +2162,7 @@
> "function (the implicit copy assignment operator)|"
> "function (the implicit move assignment operator)|"
> "constructor (inherited)}0%1"
> - " not viable: no known conversion from %2 to %3 for "
> + " not viable: no known conversion %diff{from | to | }2,3for "
> "%select{%ordinal5 argument|object argument}4; "
> "%select{|dereference the argument with *|"
> "take the address of the argument with &|"
>
> Modified: cfe/trunk/include/clang/Driver/Options.td
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Driver/Options.td?rev=159216&r1=159215&r2=159216&view=diff
> ==============================================================================
> --- cfe/trunk/include/clang/Driver/Options.td (original)
> +++ cfe/trunk/include/clang/Driver/Options.td Tue Jun 26 13:18:47 2012
> @@ -358,6 +358,9 @@
> Group<f_Group>, Flags<[CC1Option]>, HelpText<"Display include stacks for diagnostic notes">;
> def fdiagnostics_format_EQ : Joined<"-fdiagnostics-format=">, Group<f_clang_Group>;
> def fdiagnostics_show_category_EQ : Joined<"-fdiagnostics-show-category=">, Group<f_clang_Group>;
> +def fdiagnostics_show_template_tree : Flag<"-fdiagnostics-show-template-tree">,
> + Group<f_Group>, Flags<[CC1Option]>,
> + HelpText<"Print a template comparison tree for differing templates">;
> def fdollars_in_identifiers : Flag<"-fdollars-in-identifiers">, Group<f_Group>,
> HelpText<"Allow '$' in identifiers">, Flags<[CC1Option]>;
> def fdwarf2_cfi_asm : Flag<"-fdwarf2-cfi-asm">, Group<f_Group>;
> @@ -365,6 +368,9 @@
> def fdwarf_directory_asm : Flag<"-fdwarf-directory-asm">, Group<f_Group>;
> def fno_dwarf_directory_asm : Flag<"-fno-dwarf-directory-asm">, Group<f_Group>, Flags<[CC1Option]>;
> def felide_constructors : Flag<"-felide-constructors">, Group<f_Group>;
> +def fno_elide_type : Flag<"-fno-elide-type">, Group<f_Group>,
> + Flags<[CC1Option]>,
> + HelpText<"Do not elide types when printing diagnostics">;
> def feliminate_unused_debug_symbols : Flag<"-feliminate-unused-debug-symbols">, Group<f_Group>;
> def femit_all_decls : Flag<"-femit-all-decls">, Group<f_Group>, Flags<[CC1Option]>,
> HelpText<"Emit all declarations, even if unused">;
>
> Modified: cfe/trunk/include/clang/Frontend/DiagnosticOptions.h
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Frontend/DiagnosticOptions.h?rev=159216&r1=159215&r2=159216&view=diff
> ==============================================================================
> --- cfe/trunk/include/clang/Frontend/DiagnosticOptions.h (original)
> +++ cfe/trunk/include/clang/Frontend/DiagnosticOptions.h Tue Jun 26 13:18:47 2012
> @@ -47,6 +47,9 @@
> /// diagnostics, indicated by markers in the
> /// input source file.
>
> + unsigned ElideType: 1; /// Elide identical types in template diffing
> + unsigned ShowTemplateTree: 1; /// Print a template tree when diffing
> +
> unsigned ErrorLimit; /// Limit # errors emitted.
> unsigned MacroBacktraceLimit; /// Limit depth of macro expansion backtrace.
> unsigned TemplateBacktraceLimit; /// Limit depth of instantiation backtrace.
>
> Modified: cfe/trunk/lib/AST/ASTDiagnostic.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/AST/ASTDiagnostic.cpp?rev=159216&r1=159215&r2=159216&view=diff
> ==============================================================================
> --- cfe/trunk/lib/AST/ASTDiagnostic.cpp (original)
> +++ cfe/trunk/lib/AST/ASTDiagnostic.cpp Tue Jun 26 13:18:47 2012
> @@ -14,7 +14,11 @@
>
> #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;
> @@ -225,6 +229,11 @@
> 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,
> @@ -244,6 +253,32 @@
>
> switch (Kind) {
> default: llvm_unreachable("unknown ArgumentKind");
> + case DiagnosticsEngine::ak_qualtype_pair: {
> + const 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;
> + break;
> + }
> +
> + // Don't fall-back during tree printing. The caller will handle
> + // this case.
> + if (TDT.PrintTree)
> + return;
> +
> + // Attempting to do a templete diff on non-templates. Set the variables
> + // and continue with regular type printing of the appropriate type.
> + Val = TDT.PrintFromType ? TDT.FromType : TDT.ToType;
> + ModLen = 0;
> + ArgLen = 0;
> + // Fall through
> + }
> case DiagnosticsEngine::ak_qualtype: {
> assert(ModLen == 0 && ArgLen == 0 &&
> "Invalid modifier for QualType argument");
> @@ -329,3 +364,901 @@
> if (NeedQuotes)
> 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;
> +
> + /// FromType - 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 FromType;
> +
> + /// ToType - The type that FromType is compared to. Only in tree printing
> + /// will this type be outputed.
> + QualType ToType;
> +
> + /// Str - Storage for the output stream.
> + llvm::SmallString<128> Str;
> +
> + /// OS - The stream used to construct the output strings.
> + llvm::raw_svector_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 {
> + /// 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 {
> + /// NextNode - The index of the next sibling node or 0.
> + unsigned NextNode;
> +
> + /// ChildNode - The index of the first child node or 0.
> + unsigned ChildNode;
> +
> + /// ParentNode - The index of the parent node.
> + unsigned ParentNode;
> +
> + /// FromType, ToType - The type arguments.
> + QualType FromType, ToType;
> +
> + /// FromExpr, ToExpr - The expression arguments.
> + Expr *FromExpr, *ToExpr;
> +
> + /// FromTD, ToTD - The template decl for template template
> + /// arguments or the type arguments that are templates.
> + TemplateDecl *FromTD, *ToTD;
> +
> + /// FromDefault, ToDefault - Whether the argument is a default argument.
> + bool FromDefault, ToDefault;
> +
> + /// Same - Whether the two arguments evaluate to the same value.
> + 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) { }
> + };
> +
> + /// FlatTree - A flattened tree used to store the DiffNodes.
> + llvm::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) {
> + FlatTree.push_back(DiffNode());
> + }
> +
> + // Node writing functions.
> + /// SetNode - Sets FromTD and ToTD of the current node.
> + void SetNode(TemplateDecl *FromTD, TemplateDecl *ToTD) {
> + FlatTree[CurrentNode].FromTD = FromTD;
> + FlatTree[CurrentNode].ToTD = ToTD;
> + }
> +
> + /// SetNode - Sets FromType and ToType of the current node.
> + void SetNode(QualType FromType, QualType ToType) {
> + FlatTree[CurrentNode].FromType = FromType;
> + FlatTree[CurrentNode].ToType = ToType;
> + }
> +
> + /// SetNode - Set FromExpr and ToExpr of the current node.
> + void SetNode(Expr *FromExpr, Expr *ToExpr) {
> + FlatTree[CurrentNode].FromExpr = FromExpr;
> + FlatTree[CurrentNode].ToExpr = ToExpr;
> + }
> +
> + /// SetSame - Sets the same flag of the current node.
> + void SetSame(bool Same) {
> + FlatTree[CurrentNode].Same = Same;
> + }
> +
> + /// SetDefault - Sets FromDefault and ToDefault flags of the current node.
> + void SetDefault(bool FromDefault, bool ToDefault) {
> + FlatTree[CurrentNode].FromDefault = FromDefault;
> + FlatTree[CurrentNode].ToDefault = ToDefault;
> + }
> +
> + /// Up - Changes the node to the parent of the current node.
> + void Up() {
> + CurrentNode = FlatTree[CurrentNode].ParentNode;
> + }
> +
> + /// AddNode - Adds a child node to the current node, then sets that node
> + /// node as the current node.
> + void AddNode() {
> + 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;
> + }
> +
> + /// NodeIsTemplate - Returns true if a template decl is set, and types are
> + /// set.
> + bool NodeIsTemplate() {
> + return (FlatTree[ReadNode].FromTD &&
> + !FlatTree[ReadNode].ToType.isNull()) ||
> + (FlatTree[ReadNode].ToTD && !FlatTree[ReadNode].ToType.isNull());
> + }
> +
> + /// NodeIsQualType - Returns true if a Qualtype is set.
> + bool NodeIsQualType() {
> + return !FlatTree[ReadNode].FromType.isNull() ||
> + !FlatTree[ReadNode].ToType.isNull();
> + }
> +
> + /// NodeIsExpr - Returns true if an expr is set.
> + bool NodeIsExpr() {
> + return FlatTree[ReadNode].FromExpr || FlatTree[ReadNode].ToExpr;
> + }
> +
> + /// NodeIsTemplateTemplate - Returns true if the argument is a template
> + /// template type.
> + bool NodeIsTemplateTemplate() {
> + return FlatTree[ReadNode].FromType.isNull() &&
> + FlatTree[ReadNode].ToType.isNull() &&
> + (FlatTree[ReadNode].FromTD || FlatTree[ReadNode].ToTD);
> + }
> +
> + /// GetNode - Gets the FromType and ToType.
> + void GetNode(QualType &FromType, QualType &ToType) {
> + FromType = FlatTree[ReadNode].FromType;
> + ToType = FlatTree[ReadNode].ToType;
> + }
> +
> + /// GetNode - Gets the FromExpr and ToExpr.
> + void GetNode(Expr *&FromExpr, Expr *&ToExpr) {
> + FromExpr = FlatTree[ReadNode].FromExpr;
> + ToExpr = FlatTree[ReadNode].ToExpr;
> + }
> +
> + /// GetNode - Gets the FromTD and ToTD.
> + void GetNode(TemplateDecl *&FromTD, TemplateDecl *&ToTD) {
> + FromTD = FlatTree[ReadNode].FromTD;
> + ToTD = FlatTree[ReadNode].ToTD;
> + }
> +
> + /// 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;
> + }
> +
> + /// FromDefault - Return true if the from argument is the default.
> + bool FromDefault() {
> + return FlatTree[ReadNode].FromDefault;
> + }
> +
> + /// ToDefault - Return true if the to argument is the default.
> + bool ToDefault() {
> + return FlatTree[ReadNode].ToDefault;
> + }
> +
> + /// Empty - Returns true if the tree has no information.
> + 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;
> +
> + /// TSTiterator - 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 TSTiterator {
> + typedef const TemplateArgument& reference;
> + typedef const TemplateArgument* pointer;
> +
> + /// 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;
> +
> + /// TSTiterator - Constructs an iterator and sets it to the first template
> + /// argument.
> + TSTiterator(const TemplateSpecializationType *TST)
> + : TST(TST), Index(0), CurrentTA(0), EndTA(0) {
> + 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);
> + }
> +
> + /// isEnd - Returns true if the iterator is one past the end.
> + bool isEnd() const {
> + return Index == TST->getNumArgs();
> + }
> +
> + /// &operator++ - Increment the iterator to the next template argument.
> + TSTiterator &operator++() {
> + assert(!isEnd() && "Iterator incremented past end of arguments.");
> +
> + // 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(!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 {
> + return &operator*();
> + }
> + };
> +
> + // 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 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>();
> + }
> +
> + /// 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 *Params =
> + FromTST->getTemplateName().getAsTemplateDecl()->getTemplateParameters();
> + unsigned TotalArgs = 0;
> + for (TSTiterator FromIter(FromTST), ToIter(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.
> + NamedDecl *ParamND = Params->getParam(
> + (TotalArgs < Params->size()) ? TotalArgs
> + : Params->size() - 1);
> + // Handle Types
> + 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 {
> + const TemplateSpecializationType *FromArgTST =
> + GetTemplateSpecializationType(Context, FromType);
> + const TemplateSpecializationType *ToArgTST =
> + GetTemplateSpecializationType(Context, ToType);
> +
> + if (FromArgTST && ToArgTST) {
> + bool SameTemplate = hasSameTemplate(FromArgTST, ToArgTST);
> + if (SameTemplate) {
> + Tree.SetNode(FromArgTST->getTemplateName().getAsTemplateDecl(),
> + ToArgTST->getTemplateName().getAsTemplateDecl());
> + DiffTemplate(FromArgTST, ToArgTST);
> + }
> + }
> + }
> + }
> + }
> +
> + // Handle Expressions
> + 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);
> + }
> +
> + // Handle Templates
> + 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();
> + }
> + }
> +
> + /// 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 (FromTST->getTemplateName().getAsTemplateDecl()->getIdentifier() ==
> + ToTST->getTemplateName().getAsTemplateDecl()->getIdentifier())
> + return true;
> +
> + // Create vectors of template aliases.
> + SmallVector<const TemplateSpecializationType*, 1> FromTemplateList,
> + ToTemplateList;
> +
> + const TemplateSpecializationType *TempToTST = ToTST, *TempFromTST = FromTST;
> + FromTemplateList.push_back(FromTST);
> + ToTemplateList.push_back(ToTST);
> +
> + // Dump every template alias into the vectors.
> + while (TempFromTST->isTypeAlias()) {
> + TempFromTST =
> + TempFromTST->getAliasedType()->getAs<TemplateSpecializationType>();
> + if (!TempFromTST)
> + break;
> + FromTemplateList.push_back(TempFromTST);
> + }
> + while (TempToTST->isTypeAlias()) {
> + TempToTST =
> + TempToTST->getAliasedType()->getAs<TemplateSpecializationType>();
> + if (!TempToTST)
> + break;
> + ToTemplateList.push_back(TempToTST);
> + }
> +
> + SmallVector<const TemplateSpecializationType*, 1>::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 ((*FromIter)->getTemplateName().getAsTemplateDecl()->getIdentifier() !=
> + (*ToIter)->getTemplateName().getAsTemplateDecl()->getIdentifier())
> + 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 ((*FromIter)->getTemplateName().getAsTemplateDecl()->getIdentifier() !=
> + (*ToIter)->getTemplateName().getAsTemplateDecl()->getIdentifier())
> + break;
> + }
> +
> + FromTST = FromIter[-1];
> + ToTST = ToIter[-1];
> +
> + return true;
> + }
> +
> + /// GetType - Retrieves the template type arguments, including default
> + /// arguments.
> + 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();
> + };
Removed extra semicolon (was breaking a -Werror build due to -Wextra-semi) here.
> +
> + /// GetExpr - Retrieves the template expression argument, including default
> + /// arguments.
> + 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();
> + }
> +
> + /// GetTemplateDecl - Retrieves the template template arguments, including
> + /// default arguments.
> + void GetTemplateDecl(const TSTiterator &Iter,
> + TemplateTemplateParmDecl *DefaultTTPD,
> + TemplateDecl *&ArgDecl) {
> + ArgDecl = 0;
> + bool isVariadic = DefaultTTPD->isParameterPack();
> +
> + TemplateArgument TA = DefaultTTPD->getDefaultArgument().getArgument();
> + TemplateDecl *DefaultTD = TA.getAsTemplate().getAsTemplateDecl();
> +
> + if (!Iter.isEnd())
> + ArgDecl = Iter->getAsTemplate().getAsTemplateDecl();
> + else if (!isVariadic)
> + ArgDecl = DefaultTD;
> + }
> +
> + /// IsEqualExpr - Returns true if the expressions evaluate to the same value.
> + 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.");
> + }
> + }
> +
> + // 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';
> + for (int i = 0; i < Indent; ++i)
> + OS << " ";
> + ++Indent;
> + }
> +
> + // Handle cases where the difference is not templates with different
> + // arguments.
> + 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.");
> + }
> +
> + // Node is root of template. Recurse on children.
> + TemplateDecl *FromTD, *ToTD;
> + Tree.GetNode(FromTD, ToTD);
> +
> + assert(Tree.HasChildren() && "Template difference not found in diff tree.");
> +
> + 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 << ">";
> + }
> +
> + // 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();
> + return;
> + }
> +
> + std::string FromTypeStr = FromType.isNull() ? "(no argument)"
> + : FromType.getAsString();
> + std::string ToTypeStr = ToType.isNull() ? "(no argument)"
> + : ToType.getAsString();
> + // 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();
> + 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;
> + }
> +
> + /// 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)
> + OS << "(no argument)";
> + else
> + E->printPretty(OS, Context, 0, Policy); return;
> + }
> +
> + /// 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.");
> + 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 << ']';
> + }
> + }
> +
> + // 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 << " * ...]";
> + }
> +
> +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),
> + // When printing a single type, the FromType is the one printed.
> + FromType(PrintFromType ? FromType : ToType),
> + ToType(PrintFromType ? ToType : FromType),
> + OS(Str),
> + IsBold(false) {
> + }
> +
> + /// DiffTemplate - Start the template type diffing.
> + void DiffTemplate() {
> + const TemplateSpecializationType *FromOrigTST =
> + GetTemplateSpecializationType(Context, FromType);
> + const TemplateSpecializationType *ToOrigTST =
> + GetTemplateSpecializationType(Context, ToType);
> +
> + // Only checking templates.
> + if (!FromOrigTST || !ToOrigTST)
> + return;
> +
> + // Different base templates.
> + if (!hasSameTemplate(FromOrigTST, ToOrigTST)) {
> + return;
> + }
> +
> + Tree.SetNode(FromType, ToType);
> +
> + // Same base template, but different arguments.
> + Tree.SetNode(FromOrigTST->getTemplateName().getAsTemplateDecl(),
> + ToOrigTST->getTemplateName().getAsTemplateDecl());
> +
> + DiffTemplate(FromOrigTST, ToOrigTST);
> + };
and here.
- David
> +
> + /// MakeString - When the two types given are templated types with the same
> + /// base template, a string representation of the type difference will be
> + /// loaded into S and return true. Otherwise, return false.
> + 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;
> + }
> +}; // end class TemplateDiff
> +} // end 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, std::string &S) {
> + if (PrintTree)
> + PrintFromType = true;
> + TemplateDiff TD(Context, FromType, ToType, PrintTree, PrintFromType,
> + ElideType, ShowColors);
> + TD.DiffTemplate();
> + return TD.MakeString(S);
> +}
>
> Modified: cfe/trunk/lib/Basic/Diagnostic.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Basic/Diagnostic.cpp?rev=159216&r1=159215&r2=159216&view=diff
> ==============================================================================
> --- cfe/trunk/lib/Basic/Diagnostic.cpp (original)
> +++ cfe/trunk/lib/Basic/Diagnostic.cpp Tue Jun 26 13:18:47 2012
> @@ -48,6 +48,9 @@
> ErrorsAsFatal = false;
> SuppressSystemWarnings = false;
> SuppressAllDiagnostics = false;
> + ElideType = true;
> + PrintTemplateTree = false;
> + ShowColors = false;
> ShowOverloads = Ovl_All;
> ExtBehavior = Ext_Ignore;
>
> @@ -660,6 +663,8 @@
> /// QualTypeVals - Pass a vector of arrays so that QualType names can be
> /// compared to see if more information is needed to be printed.
> SmallVector<intptr_t, 2> QualTypeVals;
> + SmallVector<char, 64> Tree;
> +
> for (unsigned i = 0, e = getNumArgs(); i < e; ++i)
> if (getArgKind(i) == DiagnosticsEngine::ak_qualtype)
> QualTypeVals.push_back(getRawArg(i));
> @@ -711,7 +716,20 @@
> assert(isdigit(*DiagStr) && "Invalid format for argument in diagnostic");
> unsigned ArgNo = *DiagStr++ - '0';
>
> + // Only used for type diffing.
> + unsigned ArgNo2 = ArgNo;
> +
> DiagnosticsEngine::ArgumentKind Kind = getArgKind(ArgNo);
> + if (Kind == DiagnosticsEngine::ak_qualtype &&
> + ModifierIs(Modifier, ModifierLen, "diff")) {
> + Kind = DiagnosticsEngine::ak_qualtype_pair;
> + assert(*DiagStr == ',' && isdigit(*(DiagStr + 1)) &&
> + "Invalid format for diff modifier");
> + ++DiagStr; // Comma.
> + ArgNo2 = *DiagStr++ - '0';
> + assert(getArgKind(ArgNo2) == DiagnosticsEngine::ak_qualtype &&
> + "Second value of type diff must be a qualtype");
> + }
>
> switch (Kind) {
> // ---- STRINGS ----
> @@ -796,18 +814,77 @@
> FormattedArgs.data(), FormattedArgs.size(),
> OutStr, QualTypeVals);
> break;
> + case DiagnosticsEngine::ak_qualtype_pair:
> + // Create a struct with all the info needed for printing.
> + TemplateDiffTypes TDT;
> + TDT.FromType = getRawArg(ArgNo);
> + TDT.ToType = getRawArg(ArgNo2);
> + TDT.ElideType = getDiags()->ElideType;
> + TDT.ShowColors = getDiags()->ShowColors;
> + intptr_t val = reinterpret_cast<intptr_t>(&TDT);
> +
> + // Print the tree.
> + if (getDiags()->PrintTemplateTree) {
> + TDT.PrintFromType = true;
> + TDT.PrintTree = true;
> + getDiags()->ConvertArgToString(Kind, val,
> + Modifier, ModifierLen,
> + Argument, ArgumentLen,
> + FormattedArgs.data(),
> + FormattedArgs.size(),
> + Tree, QualTypeVals);
> + // If there is no tree information, fall back to regular printing.
> + if (!Tree.empty())
> + break;
> + }
> +
> + // Non-tree printing, also the fall-back when tree printing fails.
> + // The fall-back is triggered when the types compared are not templates.
> + const char *ArgumentEnd = Argument + ArgumentLen;
> + const char *FirstPipe = ScanFormat(Argument, ArgumentEnd, '|');
> + const char *SecondPipe = ScanFormat(FirstPipe + 1, ArgumentEnd, '|');
> +
> + // Append before text
> + FormatDiagnostic(Argument, FirstPipe, OutStr);
> +
> + // Append first type
> + TDT.PrintTree = false;
> + TDT.PrintFromType = true;
> + getDiags()->ConvertArgToString(Kind, val,
> + Modifier, ModifierLen,
> + Argument, ArgumentLen,
> + FormattedArgs.data(), FormattedArgs.size(),
> + OutStr, QualTypeVals);
> + // Append middle text
> + FormatDiagnostic(FirstPipe + 1, SecondPipe, OutStr);
> +
> + // Append second type
> + TDT.PrintFromType = false;
> + getDiags()->ConvertArgToString(Kind, val,
> + Modifier, ModifierLen,
> + Argument, ArgumentLen,
> + FormattedArgs.data(), FormattedArgs.size(),
> + OutStr, QualTypeVals);
> + // Append end text
> + FormatDiagnostic(SecondPipe + 1, ArgumentEnd, OutStr);
> + break;
> }
>
> // Remember this argument info for subsequent formatting operations. Turn
> // std::strings into a null terminated string to make it be the same case as
> // all the other ones.
> - if (Kind != DiagnosticsEngine::ak_std_string)
> + if (Kind == DiagnosticsEngine::ak_qualtype_pair)
> + continue;
> + else if (Kind != DiagnosticsEngine::ak_std_string)
> FormattedArgs.push_back(std::make_pair(Kind, getRawArg(ArgNo)));
> else
> FormattedArgs.push_back(std::make_pair(DiagnosticsEngine::ak_c_string,
> (intptr_t)getArgStdStr(ArgNo).c_str()));
>
> }
> +
> + // Append the type tree to the end of the diagnostics.
> + OutStr.append(Tree.begin(), Tree.end());
> }
>
> StoredDiagnostic::StoredDiagnostic() { }
>
> Modified: cfe/trunk/lib/Driver/Tools.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Driver/Tools.cpp?rev=159216&r1=159215&r2=159216&view=diff
> ==============================================================================
> --- cfe/trunk/lib/Driver/Tools.cpp (original)
> +++ cfe/trunk/lib/Driver/Tools.cpp Tue Jun 26 13:18:47 2012
> @@ -2203,6 +2203,8 @@
> Args.AddLastArg(CmdArgs, options::OPT_fno_limit_debug_info);
> Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
> Args.AddLastArg(CmdArgs, options::OPT_faltivec);
> + Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
> + Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
>
> // Report and error for -faltivec on anything other then PowerPC.
> if (const Arg *A = Args.getLastArg(options::OPT_faltivec))
>
> Modified: cfe/trunk/lib/Frontend/CompilerInvocation.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Frontend/CompilerInvocation.cpp?rev=159216&r1=159215&r2=159216&view=diff
> ==============================================================================
> --- cfe/trunk/lib/Frontend/CompilerInvocation.cpp (original)
> +++ cfe/trunk/lib/Frontend/CompilerInvocation.cpp Tue Jun 26 13:18:47 2012
> @@ -1349,6 +1349,8 @@
> Opts.ShowSourceRanges = Args.hasArg(OPT_fdiagnostics_print_source_range_info);
> Opts.ShowParseableFixits = Args.hasArg(OPT_fdiagnostics_parseable_fixits);
> Opts.VerifyDiagnostics = Args.hasArg(OPT_verify);
> + Opts.ElideType = !Args.hasArg(OPT_fno_elide_type);
> + Opts.ShowTemplateTree = Args.hasArg(OPT_fdiagnostics_show_template_tree);
> Opts.ErrorLimit = Args.getLastArgIntValue(OPT_ferror_limit, 0, Diags);
> Opts.MacroBacktraceLimit
> = Args.getLastArgIntValue(OPT_fmacro_backtrace_limit,
>
> Modified: cfe/trunk/lib/Frontend/TextDiagnostic.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Frontend/TextDiagnostic.cpp?rev=159216&r1=159215&r2=159216&view=diff
> ==============================================================================
> --- cfe/trunk/lib/Frontend/TextDiagnostic.cpp (original)
> +++ cfe/trunk/lib/Frontend/TextDiagnostic.cpp Tue Jun 26 13:18:47 2012
> @@ -31,12 +31,29 @@
> raw_ostream::GREEN;
> static const enum raw_ostream::Colors warningColor =
> raw_ostream::MAGENTA;
> +static const enum raw_ostream::Colors templateColor =
> + raw_ostream::CYAN;
> static const enum raw_ostream::Colors errorColor = raw_ostream::RED;
> static const enum raw_ostream::Colors fatalColor = raw_ostream::RED;
> // Used for changing only the bold attribute.
> static const enum raw_ostream::Colors savedColor =
> raw_ostream::SAVEDCOLOR;
>
> +/// \brief Add highlights to differences in template strings.
> +static void applyTemplateHighlighting(raw_ostream &OS, StringRef Str,
> + bool &Normal) {
> + for (unsigned i = 0, e = Str.size(); i < e; ++i)
> + if (Str[i] != ToggleHighlight) {
> + OS << Str[i];
> + } else {
> + if (Normal)
> + OS.changeColor(templateColor, true);
> + else
> + OS.resetColor();
> + Normal = !Normal;
> + }
> +}
> +
> /// \brief Number of spaces to indent when word-wrapping.
> const unsigned WordWrapIndentation = 6;
>
> @@ -578,6 +595,7 @@
> unsigned Column = 0,
> unsigned Indentation = WordWrapIndentation) {
> const unsigned Length = std::min(Str.find('\n'), Str.size());
> + bool TextNormal = true;
>
> // The string used to indent each line.
> SmallString<16> IndentStr;
> @@ -601,7 +619,8 @@
> OS << ' ';
> Column += 1;
> }
> - OS << Str.substr(WordStart, WordLength);
> + applyTemplateHighlighting(OS, Str.substr(WordStart, WordLength),
> + TextNormal);
> Column += WordLength;
> continue;
> }
> @@ -610,13 +629,16 @@
> // line.
> OS << '\n';
> OS.write(&IndentStr[0], Indentation);
> - OS << Str.substr(WordStart, WordLength);
> + applyTemplateHighlighting(OS, Str.substr(WordStart, WordLength),
> + TextNormal);
> Column = Indentation + WordLength;
> Wrapped = true;
> }
>
> // Append any remaning text from the message with its existing formatting.
> - OS << Str.substr(Length);
> + applyTemplateHighlighting(OS, Str.substr(Length), TextNormal);
> +
> + assert(TextNormal && "Text highlighted at end of diagnostic message.");
>
> return Wrapped;
> }
>
> Modified: cfe/trunk/lib/Frontend/Warnings.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Frontend/Warnings.cpp?rev=159216&r1=159215&r2=159216&view=diff
> ==============================================================================
> --- cfe/trunk/lib/Frontend/Warnings.cpp (original)
> +++ cfe/trunk/lib/Frontend/Warnings.cpp Tue Jun 26 13:18:47 2012
> @@ -53,7 +53,11 @@
> Diags.setIgnoreAllWarnings(Opts.IgnoreWarnings);
> Diags.setShowOverloads(
> static_cast<DiagnosticsEngine::OverloadsShown>(Opts.ShowOverloads));
> -
> +
> + Diags.setElideType(Opts.ElideType);
> + Diags.setPrintTemplateTree(Opts.ShowTemplateTree);
> + Diags.setShowColors(Opts.ShowColors);
> +
> // Handle -ferror-limit
> if (Opts.ErrorLimit)
> Diags.setErrorLimit(Opts.ErrorLimit);
>
> Modified: cfe/trunk/test/Misc/diag-aka-types.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/Misc/diag-aka-types.cpp?rev=159216&r1=159215&r2=159216&view=diff
> ==============================================================================
> --- cfe/trunk/test/Misc/diag-aka-types.cpp (original)
> +++ cfe/trunk/test/Misc/diag-aka-types.cpp Tue Jun 26 13:18:47 2012
> @@ -30,27 +30,6 @@
> bar::f(x); // expected-error{{cannot initialize a parameter of type 'Foo::foo *' (aka 'bar::Foo::foo *') with an lvalue of type 'Foo::foo *'}}
> }
>
> -// PR9548 - "no known conversion from 'vector<string>' to 'vector<string>'"
> -// vector<string> refers to two different types here. Make sure the message
> -// gives a way to tell them apart.
> -class versa_string;
> -typedef versa_string string;
> -
> -namespace std {template <typename T> class vector;}
> -using std::vector;
> -
> -void f(vector<string> v); // expected-note {{candidate function not viable: no known conversion from 'vector<string>' (aka 'std::vector<std::basic_string>') to 'vector<string>' (aka 'std::vector<versa_string>') for 1st argument}}
> -
> -namespace std {
> - class basic_string;
> - typedef basic_string string;
> - template <typename T> class vector {};
> - void g() {
> - vector<string> v;
> - f(v); // expected-error{{no matching function for call to 'f'}}
> - }
> -}
> -
> namespace ns {
> struct str {
> static void method(struct data *) {}
>
> Added: cfe/trunk/test/Misc/diag-template-diffing.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/Misc/diag-template-diffing.cpp?rev=159216&view=auto
> ==============================================================================
> --- cfe/trunk/test/Misc/diag-template-diffing.cpp (added)
> +++ cfe/trunk/test/Misc/diag-template-diffing.cpp Tue Jun 26 13:18:47 2012
> @@ -0,0 +1,433 @@
> +// RUN: %clang_cc1 -fsyntax-only %s -std=c++11 2>&1 | FileCheck %s -check-prefix=CHECK-ELIDE-NOTREE
> +// RUN: %clang_cc1 -fsyntax-only %s -fno-elide-type -std=c++11 2>&1 | FileCheck %s -check-prefix=CHECK-NOELIDE-NOTREE
> +// RUN: %clang_cc1 -fsyntax-only %s -fdiagnostics-show-template-tree -std=c++11 2>&1 | FileCheck %s -check-prefix=CHECK-ELIDE-TREE
> +// RUN: %clang_cc1 -fsyntax-only %s -fno-elide-type -fdiagnostics-show-template-tree -std=c++11 2>&1 | FileCheck %s -check-prefix=CHECK-NOELIDE-TREE
> +
> +// PR9548 - "no known conversion from 'vector<string>' to 'vector<string>'"
> +// vector<string> refers to two different types here. Make sure the message
> +// gives a way to tell them apart.
> +class versa_string;
> +typedef versa_string string;
> +
> +namespace std {template <typename T> class vector;}
> +using std::vector;
> +
> +void f(vector<string> v);
> +
> +namespace std {
> + class basic_string;
> + typedef basic_string string;
> + template <typename T> class vector {};
> + void g() {
> + vector<string> v;
> + f(v);
> + }
> +} // end namespace std
> +// CHECK-ELIDE-NOTREE: no matching function for call to 'f'
> +// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<class std::basic_string>' to 'vector<class versa_string>' for 1st argument
> +// CHECK-NOELIDE-NOTREE: no matching function for call to 'f'
> +// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<class std::basic_string>' to 'vector<class versa_string>' for 1st argument
> +// CHECK-ELIDE-TREE: no matching function for call to 'f'
> +// CHECK-ELIDE-TREE: candidate function not viable: no known conversion for 1st argument
> +// CHECK-ELIDE-TREE: vector<
> +// CHECK-ELIDE-TREE: [class std::basic_string != class versa_string]>
> +// CHECK-NOELIDE-TREE: no matching function for call to 'f'
> +// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion for 1st argument
> +// CHECK-NOELIDE-TREE: vector<
> +// CHECK-NOELIDE-TREE: [class std::basic_string != class versa_string]>
> +
> +template <int... A>
> +class I1{};
> +void set1(I1<1,2,3,4,2,3,4,3>) {};
> +void test1() {
> + set1(I1<1,2,3,4,2,2,4,3,7>());
> +}
> +// CHECK-ELIDE-NOTREE: no matching function for call to 'set1'
> +// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'I1<[5 * ...], 2, [2 * ...], 7>' to 'I1<[5 * ...], 3, [2 * ...], (no argument)>' for 1st argument
> +// CHECK-NOELIDE-NOTREE: no matching function for call to 'set1'
> +// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'I1<1, 2, 3, 4, 2, 2, 4, 3, 7>' to 'I1<1, 2, 3, 4, 2, 3, 4, 3, (no argument)>' for 1st argument
> +// CHECK-ELIDE-TREE: no matching function for call to 'set1'
> +// CHECK-ELIDE-TREE: candidate function not viable: no known conversion for 1st argument
> +// CHECK-ELIDE-TREE: I1<
> +// CHECK-ELIDE-TREE: [5 * ...],
> +// CHECK-ELIDE-TREE: [2 != 3],
> +// CHECK-ELIDE-TREE: [2 * ...],
> +// CHECK-ELIDE-TREE: [7 != (no argument)]>
> +// CHECK-NOELIDE-TREE: no matching function for call to 'set1'
> +// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion for 1st argument
> +// CHECK-NOELIDE-TREE: I1<
> +// CHECK-NOELIDE-TREE: 1,
> +// CHECK-NOELIDE-TREE: 2,
> +// CHECK-NOELIDE-TREE: 3,
> +// CHECK-NOELIDE-TREE: 4,
> +// CHECK-NOELIDE-TREE: 2,
> +// CHECK-NOELIDE-TREE: [2 != 3],
> +// CHECK-NOELIDE-TREE: 4,
> +// CHECK-NOELIDE-TREE: 3,
> +// CHECK-NOELIDE-TREE: [7 != (no argument)]>
> +
> +template <class A, class B, class C = void>
> +class I2{};
> +void set2(I2<int, int>) {};
> +void test2() {
> + set2(I2<double, int, int>());
> +}
> +// CHECK-ELIDE-NOTREE: no matching function for call to 'set2'
> +// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'I2<double, [...], int>' to 'I2<int, [...], (default) void>' for 1st argument
> +// CHECK-NOELIDE-NOTREE: no matching function for call to 'set2'
> +// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'I2<double, int, int>' to 'I2<int, int, (default) void>' for 1st argument
> +// CHECK-ELIDE-TREE: no matching function for call to 'set2'
> +// CHECK-ELIDE-TREE: candidate function not viable: no known conversion for 1st argument
> +// CHECK-ELIDE-TREE: I2<
> +// CHECK-ELIDE-TREE: [double != int],
> +// CHECK-ELIDE-TREE: [...],
> +// CHECK-ELIDE-TREE: [int != (default) void]>
> +// CHECK-NOELIDE-TREE: no matching function for call to 'set2'
> +// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion for 1st argument
> +// CHECK-NOELIDE-TREE: I2<
> +// CHECK-NOELIDE-TREE: [double != int],
> +// CHECK-NOELIDE-TREE: int,
> +// CHECK-NOELIDE-TREE: [int != (default) void]>
> +
> +int V1, V2, V3;
> +template <int* A, int *B>
> +class I3{};
> +void set3(I3<&V1, &V2>) {};
> +void test3() {
> + set3(I3<&V3, &V2>());
> +}
> +// CHECK-ELIDE-NOTREE: no matching function for call to 'set3'
> +// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'I3<&V3, [...]>' to 'I3<&V1, [...]>' for 1st argument
> +// CHECK-NOELIDE-NOTREE: no matching function for call to 'set3'
> +// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'I3<&V3, &V2>' to 'I3<&V1, &V2>' for 1st argument
> +// CHECK-ELIDE-TREE: no matching function for call to 'set3'
> +// CHECK-ELIDE-TREE: candidate function not viable: no known conversion for 1st argument
> +// CHECK-ELIDE-TREE: I3<
> +// CHECK-ELIDE-TREE: [&V3 != &V1]
> +// CHECK-ELIDE-TREE: [...]>
> +// CHECK-NOELIDE-TREE: no matching function for call to 'set3'
> +// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion for 1st argument
> +// CHECK-NOELIDE-TREE: I3<
> +// CHECK-NOELIDE-TREE: [&V3 != &V1]
> +// CHECK-NOELIDE-TREE: &V2>
> +
> +template <class A, class B>
> +class Alpha{};
> +template <class A, class B>
> +class Beta{};
> +template <class A, class B>
> +class Gamma{};
> +template <class A, class B>
> +class Delta{};
> +
> +void set4(Alpha<int, int>);
> +void test4() {
> + set4(Beta<void, void>());
> +}
> +// CHECK-ELIDE-NOTREE: no matching function for call to 'set4'
> +// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'Beta<void, void>' to 'Alpha<int, int>' for 1st argument
> +// CHECK-NOELIDE-NOTREE: no matching function for call to 'set4'
> +// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'Beta<void, void>' to 'Alpha<int, int>' for 1st argument
> +// CHECK-ELIDE-TREE: no matching function for call to 'set4'
> +// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from 'Beta<void, void>' to 'Alpha<int, int>' for 1st argument
> +// CHECK-NOELIDE-TREE: no matching function for call to 'set4'
> +// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from 'Beta<void, void>' to 'Alpha<int, int>' for 1st argument
> +
> +void set5(Alpha<Beta<Gamma<Delta<int, int>, int>, int>, int>);
> +void test5() {
> + set5(Alpha<Beta<Gamma<void, void>, double>, double>());
> +}
> +// CHECK-ELIDE-NOTREE: no matching function for call to 'set5'
> +// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'Alpha<Beta<Gamma<void, void>, double>, double>' to 'Alpha<Beta<Gamma<Delta<int, int>, int>, int>, int>' for 1st argument
> +// CHECK-NOELIDE-NOTREE: no matching function for call to 'set5'
> +// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'Alpha<Beta<Gamma<void, void>, double>, double>' to 'Alpha<Beta<Gamma<Delta<int, int>, int>, int>, int>' for 1st argument
> +// CHECK-ELIDE-TREE: no matching function for call to 'set5'
> +// CHECK-ELIDE-TREE: candidate function not viable: no known conversion for 1st argument
> +// CHECK-ELIDE-TREE: Alpha<
> +// CHECK-ELIDE-TREE: Beta<
> +// CHECK-ELIDE-TREE: Gamma<
> +// CHECK-ELIDE-TREE: [void != Delta<int, int>],
> +// CHECK-ELIDE-TREE: [void != int]>
> +// CHECK-ELIDE-TREE: [double != int]>
> +// CHECK-ELIDE-TREE: [double != int]>
> +// CHECK-NOELIDE-TREE: no matching function for call to 'set5'
> +// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion for 1st argument
> +// CHECK-NOELIDE-TREE: Alpha<
> +// CHECK-NOELIDE-TREE: Beta<
> +// CHECK-NOELIDE-TREE: Gamma<
> +// CHECK-NOELIDE-TREE: [void != Delta<int, int>],
> +// CHECK-NOELIDE-TREE: [void != int]>
> +// CHECK-NOELIDE-TREE: [double != int]>
> +// CHECK-NOELIDE-TREE: [double != int]>
> +
> +void test6() {
> + set5(Alpha<Beta<Delta<int, int>, int>, int>());
> +}
> +// CHECK-ELIDE-NOTREE: no matching function for call to 'set5'
> +// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'Alpha<Beta<Delta<int, int>, [...]>, [...]>' to 'Alpha<Beta<Gamma<Delta<int, int>, int>, [...]>, [...]>' for 1st argument
> +// CHECK-NOELIDE-NOTREE: no matching function for call to 'set5'
> +// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'Alpha<Beta<Delta<int, int>, int>, int>' to 'Alpha<Beta<Gamma<Delta<int, int>, int>, int>, int>' for 1st argument
> +// CHECK-ELIDE-TREE: no matching function for call to 'set5'
> +// CHECK-ELIDE-TREE: candidate function not viable: no known conversion for 1st argument
> +// CHECK-ELIDE-TREE: Alpha<
> +// CHECK-ELIDE-TREE: Beta<
> +// CHECK-ELIDE-TREE: [Delta<int, int> != Gamma<Delta<int, int>, int>],
> +// CHECK-ELIDE-TREE: [...]>
> +// CHECK-ELIDE-TREE: [...]>
> +// CHECK-NOELIDE-TREE: no matching function for call to 'set5'
> +// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion for 1st argument
> +// CHECK-NOELIDE-TREE: Alpha<
> +// CHECK-NOELIDE-TREE: Beta<
> +// CHECK-NOELIDE-TREE: [Delta<int, int> != Gamma<Delta<int, int>, int>],
> +// CHECK-NOELIDE-TREE: int>
> +// CHECK-NOELIDE-TREE: int>
> +
> +int a7, b7;
> +int c7[] = {1,2,3};
> +template<int *A>
> +class class7 {};
> +void set7(class7<&a7> A) {}
> +void test7() {
> + set7(class7<&a7>());
> + set7(class7<&b7>());
> + set7(class7<c7>());
> + set7(class7<nullptr>());
> +}
> +// CHECK-ELIDE-NOTREE: no matching function for call to 'set7'
> +// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'class7<&b7>' to 'class7<&a7>' for 1st argument;
> +// CHECK-ELIDE-NOTREE: no matching function for call to 'set7'
> +// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'class7<c7>' to 'class7<&a7>' for 1st argument;
> +// CHECK-ELIDE-NOTREE: no matching function for call to 'set7'
> +// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'class7<nullptr>' to 'class7<&a7>' for 1st argument;
> +// CHECK-NOELIDE-NOTREE: no matching function for call to 'set7'
> +// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'class7<&b7>' to 'class7<&a7>' for 1st argument;
> +// CHECK-NOELIDE-NOTREE: no matching function for call to 'set7'
> +// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'class7<c7>' to 'class7<&a7>' for 1st argument;
> +// CHECK-NOELIDE-NOTREE: no matching function for call to 'set7'
> +// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'class7<nullptr>' to 'class7<&a7>' for 1st argument;
> +// CHECK-ELIDE-TREE: no matching function for call to 'set7'
> +// CHECK-ELIDE-TREE: candidate function not viable: no known conversion for 1st argument;
> +// CHECK-ELIDE-TREE: class7<
> +// CHECK-ELIDE-TREE: [&b7 != &a7]>
> +// CHECK-ELIDE-TREE: no matching function for call to 'set7'
> +// CHECK-ELIDE-TREE: candidate function not viable: no known conversion for 1st argument;
> +// CHECK-ELIDE-TREE: class7<
> +// CHECK-ELIDE-TREE: [c7 != &a7]>
> +// CHECK-ELIDE-TREE: no matching function for call to 'set7'
> +// CHECK-ELIDE-TREE: candidate function not viable: no known conversion for 1st argument;
> +// CHECK-ELIDE-TREE: class7<
> +// CHECK-ELIDE-TREE: [nullptr != &a7]>
> +// CHECK-NOELIDE-TREE: no matching function for call to 'set7'
> +// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion for 1st argument;
> +// CHECK-NOELIDE-TREE: class7<
> +// CHECK-NOELIDE-TREE: [&b7 != &a7]>
> +// CHECK-NOELIDE-TREE: no matching function for call to 'set7'
> +// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion for 1st argument;
> +// CHECK-NOELIDE-TREE: class7<
> +// CHECK-NOELIDE-TREE: [c7 != &a7]>
> +// CHECK-NOELIDE-TREE: no matching function for call to 'set7'
> +// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion for 1st argument;
> +// CHECK-NOELIDE-TREE: class7<
> +// CHECK-NOELIDE-TREE: [nullptr != &a7]>
> +
> +template<typename ...T> struct S8 {};
> +template<typename T> using U8 = S8<int, char, T>;
> +int f8(S8<int, char, double>);
> +int k8 = f8(U8<char>());
> +// CHECK-ELIDE-NOTREE: no matching function for call to 'f8'
> +// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'S8<[2 * ...], char>' to 'S8<[2 * ...], double>' for 1st argument;
> +// CHECK-NOELIDE-NOTREE: no matching function for call to 'f8'
> +// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'S8<int, char, char>' to 'S8<int, char, double>' for 1st argument;
> +// CHECK-ELIDE-TREE: no matching function for call to 'f8'
> +// CHECK-ELIDE-TREE: candidate function not viable: no known conversion for 1st argument;
> +// CHECK-ELIDE-TREE: S8<
> +// CHECK-ELIDE-TREE: [2 * ...],
> +// CHECK-ELIDE-TREE: [char != double]>
> +// CHECK-NOELIDE-TREE: no matching function for call to 'f8'
> +// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion for 1st argument;
> +// CHECK-NOELIDE-TREE: S8<
> +// CHECK-NOELIDE-TREE: int,
> +// CHECK-NOELIDE-TREE: char,
> +// CHECK-NOELIDE-TREE: [char != double]>
> +
> +template<typename ...T> struct S9 {};
> +template<typename T> using U9 = S9<int, char, T>;
> +template<typename T> using V9 = U9<U9<T>>;
> +int f9(S9<int, char, U9<const double>>);
> +int k9 = f9(V9<double>());
> +
> +// CHECK-ELIDE-NOTREE: no matching function for call to 'f9'
> +// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'S9<[2 * ...], S9<[2 * ...], double>>' to 'S9<[2 * ...], S9<[2 * ...], const double>>' for 1st argument;
> +// CHECK-NOELIDE-NOTREE: no matching function for call to 'f9'
> +// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'S9<int, char, S9<int, char, double>>' to 'S9<int, char, S9<int, char, const double>>' for 1st argument;
> +// CHECK-ELIDE-TREE: no matching function for call to 'f9'
> +// CHECK-ELIDE-TREE: candidate function not viable: no known conversion for 1st argument;
> +// CHECK-ELIDE-TREE: S9<
> +// CHECK-ELIDE-TREE: [2 * ...],
> +// CHECK-ELIDE-TREE: S9<
> +// CHECK-ELIDE-TREE: [2 * ...],
> +// CHECK-ELIDE-TREE: [double != const double]>>
> +// CHECK-NOELIDE-TREE: no matching function for call to 'f9'
> +// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion for 1st argument;
> +// CHECK-NOELIDE-TREE: S9<
> +// CHECK-NOELIDE-TREE: int,
> +// CHECK-NOELIDE-TREE: char,
> +// CHECK-NOELIDE-TREE: S9<
> +// CHECK-NOELIDE-TREE: int,
> +// CHECK-NOELIDE-TREE: char,
> +// CHECK-NOELIDE-TREE: [double != const double]>>
> +
> +template<typename ...A> class class_types {};
> +void set10(class_types<int, int>) {}
> +void test10() {
> + set10(class_types<int>());
> + set10(class_types<int, int, int>());
> +}
> +
> +// CHECK-ELIDE-NOTREE: no matching function for call to 'set10'
> +// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'class_types<[...], (no argument)>' to 'class_types<[...], int>' for 1st argument;
> +// CHECK-ELIDE-NOTREE: no matching function for call to 'set10'
> +// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'class_types<[2 * ...], int>' to 'class_types<[2 * ...], (no argument)>' for 1st argument;
> +// CHECK-NOELIDE-NOTREE: no matching function for call to 'set10'
> +// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'class_types<int, (no argument)>' to 'class_types<int, int>' for 1st argument;
> +// CHECK-NOELIDE-NOTREE: no matching function for call to 'set10'
> +// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'class_types<int, int, int>' to 'class_types<int, int, (no argument)>' for 1st argument;
> +// CHECK-ELIDE-TREE: no matching function for call to 'set10'
> +// CHECK-ELIDE-TREE: candidate function not viable: no known conversion for 1st argument;
> +// CHECK-ELIDE-TREE: class_types<
> +// CHECK-ELIDE-TREE: [...],
> +// CHECK-ELIDE-TREE: [(no argument) != int]>
> +// CHECK-ELIDE-TREE: no matching function for call to 'set10'
> +// CHECK-ELIDE-TREE: candidate function not viable: no known conversion for 1st argument;
> +// CHECK-ELIDE-TREE: class_types<
> +// CHECK-ELIDE-TREE: [2 * ...],
> +// CHECK-ELIDE-TREE: [int != (no argument)]>
> +// CHECK-NOELIDE-TREE: no matching function for call to 'set10'
> +// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion for 1st argument;
> +// CHECK-NOELIDE-TREE: class_types<
> +// CHECK-NOELIDE-TREE: int,
> +// CHECK-NOELIDE-TREE: [(no argument) != int]>
> +// CHECK-NOELIDE-TREE: no matching function for call to 'set10'
> +// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion for 1st argument;
> +// CHECK-NOELIDE-TREE: class_types<
> +// CHECK-NOELIDE-TREE: int,
> +// CHECK-NOELIDE-TREE: int,
> +// CHECK-NOELIDE-TREE: [int != (no argument)]>
> +
> +template<int ...A> class class_ints {};
> +void set11(class_ints<2, 3>) {}
> +void test11() {
> + set11(class_ints<1>());
> + set11(class_ints<0, 3, 6>());
> +}
> +// CHECK-ELIDE-NOTREE: no matching function for call to 'set11'
> +// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'class_ints<1, (no argument)>' to 'class_ints<2, 3>' for 1st argument;
> +// CHECK-ELIDE-NOTREE: no matching function for call to 'set11'
> +// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'class_ints<0, [...], 6>' to 'class_ints<2, [...], (no argument)>' for 1st argument;
> +// CHECK-NOELIDE-NOTREE: no matching function for call to 'set11'
> +// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'class_ints<1, (no argument)>' to 'class_ints<2, 3>' for 1st argument;
> +// CHECK-NOELIDE-NOTREE: no matching function for call to 'set11'
> +// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'class_ints<0, 3, 6>' to 'class_ints<2, 3, (no argument)>' for 1st argument;
> +// CHECK-ELIDE-TREE: no matching function for call to 'set11'
> +// CHECK-ELIDE-TREE: candidate function not viable: no known conversion for 1st argument;
> +// CHECK-ELIDE-TREE: class_ints<
> +// CHECK-ELIDE-TREE: [1 != 2],
> +// CHECK-ELIDE-TREE: [(no argument) != 3]>
> +// CHECK-ELIDE-TREE: no matching function for call to 'set11'
> +// CHECK-ELIDE-TREE: candidate function not viable: no known conversion for 1st argument;
> +// CHECK-ELIDE-TREE: class_ints<
> +// CHECK-ELIDE-TREE: [0 != 2],
> +// CHECK-ELIDE-TREE: [...],
> +// CHECK-ELIDE-TREE: [6 != (no argument)]>
> +// CHECK-NOELIDE-TREE: no matching function for call to 'set11'
> +// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion for 1st argument;
> +// CHECK-NOELIDE-TREE: class_ints<
> +// CHECK-NOELIDE-TREE: [1 != 2],
> +// CHECK-NOELIDE-TREE: [(no argument) != 3]>
> +// CHECK-NOELIDE-TREE: no matching function for call to 'set11'
> +// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion for 1st argument;
> +// CHECK-NOELIDE-TREE: class_ints<
> +// CHECK-NOELIDE-TREE: [0 != 2],
> +// CHECK-NOELIDE-TREE: 3,
> +// CHECK-NOELIDE-TREE: [6 != (no argument)]>
> +
> +template<template<class> class ...A> class class_template_templates {};
> +template<class> class tt1 {};
> +template<class> class tt2 {};
> +void set12(class_template_templates<tt1, tt1>) {}
> +void test12() {
> + set12(class_template_templates<tt2>());
> + set12(class_template_templates<tt1, tt1, tt1>());
> +}
> +// CHECK-ELIDE-NOTREE: no matching function for call to 'set12'
> +// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'class_template_templates<template tt2, template (no argument)>' to 'class_template_templates<template tt1, template tt1>' for 1st argument;
> +// CHECK-ELIDE-NOTREE: no matching function for call to 'set12'
> +// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'class_template_templates<[2 * ...], template tt1>' to 'class_template_templates<[2 * ...], template (no argument)>' for 1st argument;
> +// CHECK-NOELIDE-NOTREE: no matching function for call to 'set12'
> +// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'class_template_templates<template tt2, template (no argument)>' to 'class_template_templates<template tt1, template tt1>' for 1st argument;
> +// CHECK-NOELIDE-NOTREE: no matching function for call to 'set12'
> +// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'class_template_templates<template tt1, template tt1, template tt1>' to 'class_template_templates<template tt1, template tt1, template (no argument)>' for 1st argument;
> +// CHECK-ELIDE-TREE: no matching function for call to 'set12'
> +// CHECK-ELIDE-TREE: candidate function not viable: no known conversion for 1st argument;
> +// CHECK-ELIDE-TREE: class_template_templates<
> +// CHECK-ELIDE-TREE: [template tt2 != template tt1],
> +// CHECK-ELIDE-TREE: [template (no argument) != template tt1]>
> +// CHECK-ELIDE-TREE: no matching function for call to 'set12'
> +// CHECK-ELIDE-TREE: candidate function not viable: no known conversion for 1st argument;
> +// CHECK-ELIDE-TREE: class_template_templates<
> +// CHECK-ELIDE-TREE: [2 * ...],
> +// CHECK-ELIDE-TREE: [template tt1 != template (no argument)]>
> +// CHECK-NOELIDE-TREE: no matching function for call to 'set12'
> +// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion for 1st argument;
> +// CHECK-NOELIDE-TREE: class_template_templates<
> +// CHECK-NOELIDE-TREE: [template tt2 != template tt1],
> +// CHECK-NOELIDE-TREE: [template (no argument) != template tt1]>
> +// CHECK-NOELIDE-TREE: no matching function for call to 'set12'
> +// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion for 1st argument;
> +// CHECK-NOELIDE-TREE: class_template_templates<
> +// CHECK-NOELIDE-TREE: template tt1,
> +// CHECK-NOELIDE-TREE: template tt1,
> +// CHECK-NOELIDE-TREE: [template tt1 != template (no argument)]>
> +
> +double a13, b13, c13, d13;
> +template<double* ...A> class class_ptrs {};
> +void set13(class_ptrs<&a13, &b13>) {}
> +void test13() {
> + set13(class_ptrs<&c13>());
> + set13(class_ptrss<&a13, &b13, &d13>());
> +}
> +// CHECK-ELIDE-NOTREE: no matching function for call to 'set13'
> +// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'class_ptrs<&c13, (no argument)>' to 'class_ptrs<&a13, &b13>' for 1st argument;
> +// CHECK-ELIDE-NOTREE: no matching function for call to 'set13'
> +// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'class_ptrs<[2 * ...], &d13>' to 'class_ptrs<[2 * ...], (no argument)>' for 1st argument;
> +// CHECK-NOELIDE-NOTREE: no matching function for call to 'set13'
> +// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'class_ptrs<&c13, (no argument)>' to 'class_ptrs<&a13, &b13>' for 1st argument;
> +// CHECK-NOELIDE-NOTREE: no matching function for call to 'set13'
> +// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'class_ptrs<&a13, &b13, &d13>' to 'class_ptrs<&a13, &b13, (no argument)>' for 1st argument;
> +// CHECK-ELIDE-TREE: no matching function for call to 'set13'
> +// CHECK-ELIDE-TREE: candidate function not viable: no known conversion for 1st argument;
> +// CHECK-ELIDE-TREE: class_ptrs<
> +// CHECK-ELIDE-TREE: [&c13 != &a13],
> +// CHECK-ELIDE-TREE: [(no argument) != &b13]>
> +// CHECK-ELIDE-TREE: no matching function for call to 'set13'
> +// CHECK-ELIDE-TREE: candidate function not viable: no known conversion for 1st argument;
> +// CHECK-ELIDE-TREE: class_ptrs<
> +// CHECK-ELIDE-TREE: [2 * ...],
> +// CHECK-ELIDE-TREE: [&d13 != (no argument)]>
> +// CHECK-NOELIDE-TREE: no matching function for call to 'set13'
> +// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion for 1st argument;
> +// CHECK-NOELIDE-TREE: class_ptrs<
> +// CHECK-NOELIDE-TREE: [&c13 != &a13],
> +// CHECK-NOELIDE-TREE: [(no argument) != &b13]>
> +// CHECK-NOELIDE-TREE: no matching function for call to 'set13'
> +// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion for 1st argument;
> +// CHECK-NOELIDE-TREE: class_ptrs<
> +// CHECK-NOELIDE-TREE: &a13,
> +// CHECK-NOELIDE-TREE: &b13,
> +// CHECK-NOELIDE-TREE: [&d13 != (no argument)]>
> +
> +
> +// CHECK-ELIDE-NOTREE: {{[0-9]*}} errors generated.
> +// CHECK-NOELIDE-NOTREE: {{[0-9]*}} errors generated.
> +// CHECK-ELIDE-TREE: {{[0-9]*}} errors generated.
> +// CHECK-NOELIDE-TREE: {{[0-9]*}} errors generated.
>
>
> _______________________________________________
> cfe-commits mailing list
> cfe-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
More information about the cfe-commits
mailing list