[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

Chandler Carruth chandlerc at google.com
Tue Jun 26 14:02:26 PDT 2012


I know we chatted about this already, but wanted to mention:

1) Release notes
2) Documentation updates


Thanks again, I'm really excited to have this. :: goes and builds a new
Clang ::


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.
>
> 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();
> +  };
> +
> +  /// 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);
> +  };
> +
> +  /// 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
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/cfe-commits/attachments/20120626/5e2ef089/attachment.html>


More information about the cfe-commits mailing list