[cfe-commits] r164843 - in /cfe/trunk: lib/AST/ASTDiagnostic.cpp test/Misc/diag-template-diffing-color.cpp test/Misc/diag-template-diffing.cpp
David Blaikie
dblaikie at gmail.com
Tue Oct 2 14:45:59 PDT 2012
On Fri, Sep 28, 2012 at 1:32 PM, Richard Trieu <rtrieu at google.com> wrote:
> Author: rtrieu
> Date: Fri Sep 28 15:32:51 2012
> New Revision: 164843
>
> URL: http://llvm.org/viewvc/llvm-project?rev=164843&view=rev
> Log:
> Update template type diffing to handle qualifiers. Differing qualifiers will
> now be printed with highlighting.
Awesome - I was just noticing the lack of this when I was adding type
diffing to the redeclaration warning the other day.
>
> Modified:
> cfe/trunk/lib/AST/ASTDiagnostic.cpp
> cfe/trunk/test/Misc/diag-template-diffing-color.cpp
> cfe/trunk/test/Misc/diag-template-diffing.cpp
>
> Modified: cfe/trunk/lib/AST/ASTDiagnostic.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/AST/ASTDiagnostic.cpp?rev=164843&r1=164842&r2=164843&view=diff
> ==============================================================================
> --- cfe/trunk/lib/AST/ASTDiagnostic.cpp (original)
> +++ cfe/trunk/lib/AST/ASTDiagnostic.cpp Fri Sep 28 15:32:51 2012
> @@ -430,6 +430,9 @@
> /// arguments or the type arguments that are templates.
> TemplateDecl *FromTD, *ToTD;
>
> + /// FromQual, ToQual - Qualifiers for template types.
> + Qualifiers FromQual, ToQual;
> +
> /// FromDefault, ToDefault - Whether the argument is a default argument.
> bool FromDefault, ToDefault;
>
> @@ -480,6 +483,12 @@
> FlatTree[CurrentNode].ToExpr = ToExpr;
> }
>
> + /// SetNode - Set FromQual and ToQual of the current node.
> + void SetNode(Qualifiers FromQual, Qualifiers ToQual) {
> + FlatTree[CurrentNode].FromQual = FromQual;
> + FlatTree[CurrentNode].ToQual = ToQual;
> + }
> +
> /// SetSame - Sets the same flag of the current node.
> void SetSame(bool Same) {
> FlatTree[CurrentNode].Same = Same;
> @@ -575,6 +584,12 @@
> ToTD = FlatTree[ReadNode].ToTD;
> }
>
> + /// GetNode - Gets the FromQual and ToQual.
> + void GetNode(Qualifiers &FromQual, Qualifiers &ToQual) {
> + FromQual = FlatTree[ReadNode].FromQual;
> + ToQual = FlatTree[ReadNode].ToQual;
> + }
> +
> /// NodeIsSame - Returns true the arguments are the same.
> bool NodeIsSame() {
> return FlatTree[ReadNode].Same;
> @@ -778,6 +793,8 @@
> if (Context.hasSameType(FromType, ToType)) {
> Tree.SetSame(true);
> } else {
> + Qualifiers FromQual = FromType.getQualifiers(),
> + ToQual = ToType.getQualifiers();
> const TemplateSpecializationType *FromArgTST =
> GetTemplateSpecializationType(Context, FromType);
> const TemplateSpecializationType *ToArgTST =
> @@ -785,8 +802,11 @@
>
> if (FromArgTST && ToArgTST &&
> hasSameTemplate(FromArgTST, ToArgTST)) {
> + FromQual -= QualType(FromArgTST, 0).getQualifiers();
> + ToQual -= QualType(ToArgTST, 0).getQualifiers();
> Tree.SetNode(FromArgTST->getTemplateName().getAsTemplateDecl(),
> ToArgTST->getTemplateName().getAsTemplateDecl());
> + Tree.SetNode(FromQual, ToQual);
> DiffTemplate(FromArgTST, ToArgTST);
> }
> }
> @@ -1027,6 +1047,10 @@
>
> assert(Tree.HasChildren() && "Template difference not found in diff tree.");
>
> + Qualifiers FromQual, ToQual;
> + Tree.GetNode(FromQual, ToQual);
> + PrintQualifiers(FromQual, ToQual);
> +
> OS << FromTD->getNameAsString() << '<';
> Tree.MoveToChild();
> unsigned NumElideArgs = 0;
> @@ -1088,6 +1112,17 @@
> return;
> }
>
> + if (!FromType.isNull() && !ToType.isNull() &&
> + FromType.getLocalUnqualifiedType() ==
> + ToType.getLocalUnqualifiedType()) {
> + Qualifiers FromQual = FromType.getLocalQualifiers(),
> + ToQual = ToType.getLocalQualifiers(),
> + CommonQual;
> + PrintQualifiers(FromQual, ToQual);
> + FromType.getLocalUnqualifiedType().print(OS, Policy);
> + return;
> + }
> +
> std::string FromTypeStr = FromType.isNull() ? "(no argument)"
> : FromType.getAsString();
> std::string ToTypeStr = ToType.isNull() ? "(no argument)"
> @@ -1191,6 +1226,68 @@
> OS << "[" << NumElideArgs << " * ...]";
> }
>
> + // Prints and highlights differences in Qualifiers.
> + void PrintQualifiers(Qualifiers FromQual, Qualifiers ToQual) {
> + // Both types have no qualifiers
> + if (FromQual.empty() && ToQual.empty())
> + return;
> +
> + // Both types have same qualifiers
> + if (FromQual == ToQual) {
> + PrintQualifier(FromQual, /*ApplyBold*/false);
> + return;
> + }
> +
> + // Find common qualifiers and strip them from FromQual and ToQual.
> + Qualifiers CommonQual = Qualifiers::removeCommonQualifiers(FromQual,
> + ToQual);
> +
> + // The qualifiers are printed before the template name.
> + // Inline printing:
> + // The common qualifiers are printed. Then, qualifiers only in this type
> + // are printed and highlighted. Finally, qualifiers only in the other
> + // type are printed and highlighted inside parentheses after "missing".
> + // Tree printing:
> + // Qualifiers are printed next to each other, inside brackets, and
> + // separated by "!=". The printing order is:
> + // common qualifiers, highlighted from qualifiers, "!=",
> + // common qualifiers, highlighted to qualifiers
> + if (PrintTree) {
> + OS << "[";
> + if (CommonQual.empty() && FromQual.empty()) {
> + Bold();
> + OS << "(no qualifiers) ";
> + Unbold();
> + } else {
> + PrintQualifier(CommonQual, /*ApplyBold*/false);
> + PrintQualifier(FromQual, /*ApplyBold*/true);
> + }
> + OS << "!= ";
> + if (CommonQual.empty() && ToQual.empty()) {
> + Bold();
> + OS << "(no qualifiers)";
> + Unbold();
> + } else {
> + PrintQualifier(CommonQual, /*ApplyBold*/false,
> + /*appendSpaceIfNonEmpty*/!ToQual.empty());
> + PrintQualifier(ToQual, /*ApplyBold*/true,
> + /*appendSpaceIfNonEmpty*/false);
> + }
> + OS << "] ";
> + } else {
> + PrintQualifier(CommonQual, /*ApplyBold*/false);
> + PrintQualifier(FromQual, /*ApplyBold*/true);
> + }
> + }
> +
> + void PrintQualifier(Qualifiers Q, bool ApplyBold,
> + bool AppendSpaceIfNonEmpty = true) {
> + if (Q.empty()) return;
> + if (ApplyBold) Bold();
> + Q.print(OS, Policy, AppendSpaceIfNonEmpty);
> + if (ApplyBold) Unbold();
> + }
> +
> public:
>
> TemplateDiff(ASTContext &Context, QualType FromType, QualType ToType,
> @@ -1210,6 +1307,9 @@
>
> /// DiffTemplate - Start the template type diffing.
> void DiffTemplate() {
> + Qualifiers FromQual = FromType.getQualifiers(),
> + ToQual = ToType.getQualifiers();
> +
> const TemplateSpecializationType *FromOrigTST =
> GetTemplateSpecializationType(Context, FromType);
> const TemplateSpecializationType *ToOrigTST =
> @@ -1224,7 +1324,10 @@
> return;
> }
>
> + FromQual -= QualType(FromOrigTST, 0).getQualifiers();
> + ToQual -= QualType(ToOrigTST, 0).getQualifiers();
> Tree.SetNode(FromType, ToType);
> + Tree.SetNode(FromQual, ToQual);
>
> // Same base template, but different arguments.
> Tree.SetNode(FromOrigTST->getTemplateName().getAsTemplateDecl(),
>
> Modified: cfe/trunk/test/Misc/diag-template-diffing-color.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/Misc/diag-template-diffing-color.cpp?rev=164843&r1=164842&r2=164843&view=diff
> ==============================================================================
> --- cfe/trunk/test/Misc/diag-template-diffing-color.cpp (original)
> +++ cfe/trunk/test/Misc/diag-template-diffing-color.cpp Fri Sep 28 15:32:51 2012
> @@ -17,3 +17,56 @@
> // TREE: non-const lvalue reference cannot bind to a value of unrelated type
> // TREE: foo<
> // TREE: [{{.}}[0;1;36mdouble{{.}}[0m{{.}}[1m != {{.}}[0;1;36mint{{.}}[0m{{.}}[1m]>{{.}}[0m
> +
> +template<typename> class vector {};
> +
> +void set15(vector<const vector<int> >) {}
> +void test15() {
> + set15(vector<const vector<const int> >());
> +}
> +// CHECK: {{.*}}candidate function not viable: no known conversion from 'vector<const vector<{{.}}[0;1;36mconst{{ ?.}}[0m{{ ?}}int>>' to 'vector<const vector<int>>' for 1st argument
> +// TREE: {{.*}}candidate function not viable: no known conversion from argument type to parameter type for 1st argument
> +// TREE: vector<
> +// TREE: const vector<
> +// TREE: [{{.}}[0;1;36mconst{{ ?.}}[0m{{ ?}}!= {{.}}[0;1;36m(no qualifiers){{.}}[0m] int>>
> +
> +void set16(vector<vector<int> >) {}
> +void test16() {
> + set16(vector<const vector<int> >());
> +}
> +// CHECK: {{.*}}candidate function not viable: no known conversion from 'vector<{{.}}[0;1;36mconst{{ ?.}}[0m{{ ?}}vector<[...]>>' to 'vector<vector<[...]>>' for 1st argument
> +// TREE: {{.*}}candidate function not viable: no known conversion from argument type to parameter type for 1st argument
> +// TREE: vector<
> +// TREE: [{{.}}[0;1;36mconst{{ ?.}}[0m{{ ?}}!= {{.}}[0;1;36m(no qualifiers){{ ?.}}[0m]{{ ?}}vector<
> +// TREE: [...]>>
> +
> +void set17(vector<const vector<int> >) {}
> +void test17() {
> + set17(vector<vector<int> >());
> +}
> +// CHECK: candidate function not viable: no known conversion from 'vector<vector<[...]>>' to 'vector<{{.}}[0;1;36mconst{{ ?.}}[0m{{ ?}}vector<[...]>>' for 1st argument
> +// TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
> +// TREE: vector<
> +// TREE: [{{.}}[0;1;36m(no qualifiers){{ ?.}}[0m{{ ?}}!= {{.}}[0;1;36mconst{{.}}[0m] vector<
> +// TREE: [...]>>
> +
> +void set18(vector<volatile vector<int> >) {}
> +void test18() {
> + set18(vector<const vector<int> >());
> +}
> +// CHECK: candidate function not viable: no known conversion from 'vector<{{.}}[0;1;36mconst{{ ?.}}[0m{{ ?}}vector<[...]>>' to 'vector<{{.}}[0;1;36mvolatile{{ ?.}}[0m{{ ?}}vector<[...]>>' for 1st argument
> +// TREE: no matching function for call to 'set18'
> +// TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
> +// TREE: vector<
> +// TREE: [{{.}}[0;1;36mconst{{ ?.}}[0m{{ ?}}!= {{.}}[0;1;36mvolatile{{.}}[0m] vector<
> +// TREE: [...]>>
> +
> +void set19(vector<const volatile vector<int> >) {}
> +void test19() {
> + set19(vector<const vector<int> >());
> +}
> +// CHECK: candidate function not viable: no known conversion from 'vector<const vector<[...]>>' to 'vector<const {{.}}[0;1;36mvolatile{{ ?.}}[0m{{ ?}}vector<[...]>>' for 1st argument
> +// TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
> +// TREE: vector<
> +// TREE: [const != const {{.}}[0;1;36mvolatile{{.}}[0m] vector<
> +// TREE: [...]>>
>
> Modified: cfe/trunk/test/Misc/diag-template-diffing.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/Misc/diag-template-diffing.cpp?rev=164843&r1=164842&r2=164843&view=diff
> ==============================================================================
> --- cfe/trunk/test/Misc/diag-template-diffing.cpp (original)
> +++ cfe/trunk/test/Misc/diag-template-diffing.cpp Fri Sep 28 15:32:51 2012
> @@ -445,6 +445,191 @@
> // CHECK-NOELIDE-TREE: a14<
> // CHECK-NOELIDE-TREE: [char != int]>
>
> +void set15(vector<vector<int>>) {}
> +void test15() {
> + set15(vector<vector<int>>());
> +}
> +// CHECK-ELIDE-NOTREE-NOT: set15
> +// CHECK-NOELIDE-NOTREE-NOT: set15
> +// CHECK-ELIDE-TREE-NOT: set15
> +// CHECK-NOELIDE-TREE-NOT: set15
> +// no error here
> +
> +void set16(vector<const vector<int>>) {}
> +void test16() {
> + set16(vector<const vector<const int>>());
> +}
> +// CHECK-ELIDE-NOTREE: no matching function for call to 'set16'
> +// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<const vector<const int>>' to 'vector<const vector<int>>' for 1st argument
> +// CHECK-NOELIDE-NOTREE: no matching function for call to 'set16'
> +// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<const vector<const int>>' to 'vector<const vector<int>>' for 1st argument
> +// CHECK-ELIDE-TREE: no matching function for call to 'set16'
> +// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
> +// CHECK-ELIDE-TREE: vector<
> +// CHECK-ELIDE-TREE: const vector<
> +// CHECK-ELIDE-TREE: [const != (no qualifiers)] int>>
> +// CHECK-NOELIDE-TREE: no matching function for call to 'set16'
> +// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
> +// CHECK-NOELIDE-TREE: vector<
> +// CHECK-NOELIDE-TREE: const vector<
> +// CHECK-NOELIDE-TREE: [const != (no qualifiers)] int>>
> +
> +void set17(vector<vector<int>>) {}
> +void test17() {
> + set17(vector<const vector<int>>());
> +}
> +// CHECK-ELIDE-NOTREE: no matching function for call to 'set17'
> +// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<const vector<[...]>>' to 'vector<vector<[...]>>' for 1st argument
> +// CHECK-NOELIDE-NOTREE: no matching function for call to 'set17'
> +// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<const vector<int>>' to 'vector<vector<int>>' for 1st argument
> +// CHECK-ELIDE-TREE: no matching function for call to 'set17'
> +// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
> +// CHECK-ELIDE-TREE: vector<
> +// CHECK-ELIDE-TREE: [const != (no qualifiers)] vector<
> +// CHECK-ELIDE-TREE: [...]>>
> +// CHECK-NOELIDE-TREE: no matching function for call to 'set17'
> +// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
> +// CHECK-NOELIDE-TREE: vector<
> +// CHECK-NOELIDE-TREE: [const != (no qualifiers)] vector<
> +// CHECK-NOELIDE-TREE: int>>
> +
> +void set18(vector<const vector<int>>) {}
> +void test18() {
> + set18(vector<vector<int>>());
> +}
> +// CHECK-ELIDE-NOTREE: no matching function for call to 'set18'
> +// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<vector<[...]>>' to 'vector<const vector<[...]>>' for 1st argument
> +// CHECK-NOELIDE-NOTREE: no matching function for call to 'set18'
> +// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<vector<int>>' to 'vector<const vector<int>>' for 1st argument
> +// CHECK-ELIDE-TREE: no matching function for call to 'set18'
> +// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
> +// CHECK-ELIDE-TREE: vector<
> +// CHECK-ELIDE-TREE: [(no qualifiers) != const] vector<
> +// CHECK-ELIDE-TREE: [...]>>
> +// CHECK-NOELIDE-TREE: no matching function for call to 'set18'
> +// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
> +// CHECK-NOELIDE-TREE: vector<
> +// CHECK-NOELIDE-TREE: [(no qualifiers) != const] vector<
> +// CHECK-NOELIDE-TREE: int>>
> +
> +void set19(vector<volatile vector<int>>) {}
> +void test19() {
> + set19(vector<const vector<int>>());
> +}
> +// CHECK-ELIDE-NOTREE: no matching function for call to 'set19'
> +// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<const vector<[...]>>' to 'vector<volatile vector<[...]>>' for 1st argument
> +// CHECK-NOELIDE-NOTREE: no matching function for call to 'set19'
> +// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<const vector<int>>' to 'vector<volatile vector<int>>' for 1st argument
> +// CHECK-ELIDE-TREE: no matching function for call to 'set19'
> +// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
> +// CHECK-ELIDE-TREE: vector<
> +// CHECK-ELIDE-TREE: [const != volatile] vector<
> +// CHECK-ELIDE-TREE: [...]>>
> +// CHECK-NOELIDE-TREE: no matching function for call to 'set19'
> +// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
> +// CHECK-NOELIDE-TREE: vector<
> +// CHECK-NOELIDE-TREE: [const != volatile] vector<
> +// CHECK-NOELIDE-TREE: int>>
> +
> +void set20(vector<const volatile vector<int>>) {}
> +void test20() {
> + set20(vector<const vector<int>>());
> +}
> +// CHECK-ELIDE-NOTREE: no matching function for call to 'set20'
> +// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<const vector<[...]>>' to 'vector<const volatile vector<[...]>>' for 1st argument
> +// CHECK-NOELIDE-NOTREE: no matching function for call to 'set20'
> +// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<const vector<int>>' to 'vector<const volatile vector<int>>' for 1st argument
> +// CHECK-ELIDE-TREE: no matching function for call to 'set20'
> +// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
> +// CHECK-ELIDE-TREE: vector<
> +// CHECK-ELIDE-TREE: [const != const volatile] vector<
> +// CHECK-ELIDE-TREE: [...]>>
> +// CHECK-NOELIDE-TREE: no matching function for call to 'set20'
> +// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
> +// CHECK-NOELIDE-TREE: vector<
> +// CHECK-NOELIDE-TREE: [const != const volatile] vector<
> +// CHECK-NOELIDE-TREE: int>>
> +
> +
> +// Checks that volatile does not show up in diagnostics.
> +template<typename T> struct S21 {};
> +template<typename T> using U21 = volatile S21<T>;
> +int f21(vector<const U21<int>>);
> +int k21 = f21(vector<U21<int>>());
> +// CHECK-ELIDE-NOTREE: no matching function for call to 'f21'
> +// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<U21<[...]>>' to 'vector<const U21<[...]>>' for 1st argument
> +// CHECK-NOELIDE-NOTREE: no matching function for call to 'f21'
> +// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<U21<int>>' to 'vector<const U21<int>>' for 1st argument
> +// CHECK-ELIDE-TREE: no matching function for call to 'f21'
> +// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
> +// CHECK-ELIDE-TREE: vector<
> +// CHECK-ELIDE-TREE: [(no qualifiers) != const] U21<
> +// CHECK-ELIDE-TREE: [...]>>
> +// CHECK-NOELIDE-TREE: no matching function for call to 'f21'
> +// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
> +// CHECK-NOELIDE-TREE: vector<
> +// CHECK-NOELIDE-TREE: [(no qualifiers) != const] U21<
> +// CHECK-NOELIDE-TREE: int>>
> +
> +// Checks that volatile does not show up in diagnostics.
> +template<typename T> struct S22 {};
> +template<typename T> using U22 = volatile S22<T>;
> +int f22(vector<volatile const U22<int>>);
> +int k22 = f22(vector<volatile U22<int>>());
> +// CHECK-ELIDE-NOTREE: no matching function for call to 'f22'
> +// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<U22<[...]>>' to 'vector<const U22<[...]>>' for 1st argument
> +// CHECK-NOELIDE-NOTREE: no matching function for call to 'f22'
> +// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<U22<int>>' to 'vector<const U22<int>>' for 1st argument
> +// CHECK-ELIDE-TREE: no matching function for call to 'f22'
> +// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
> +// CHECK-ELIDE-TREE: vector<
> +// CHECK-ELIDE-TREE: [(no qualifiers) != const] U22<
> +// CHECK-ELIDE-TREE: [...]>>
> +// CHECK-NOELIDE-TREE: no matching function for call to 'f22'
> +// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
> +// CHECK-NOELIDE-TREE: vector<
> +// CHECK-NOELIDE-TREE: [(no qualifiers) != const] U22<
> +// CHECK-NOELIDE-TREE: int>>
> +
> +// Testing qualifiers and typedefs.
> +template <class T> struct D23{};
> +template <class T> using C23 = D23<T>;
> +typedef const C23<int> B23;
> +template<class ...T> using A23 = B23;
> +
> +void foo23(D23<A23<>> b) {}
> +void test23() {
> + foo23(D23<D23<char>>());
> + foo23(C23<char>());
> +}
> +
> +// CHECK-ELIDE-NOTREE: no matching function for call to 'foo23'
> +// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'D23<D23<char>>' to 'D23<const D23<int>>' for 1st argument
> +// CHECK-ELIDE-NOTREE: no matching function for call to 'foo23'
> +// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'D23<char>' to 'D23<A23<>>' for 1st argument
> +// CHECK-NOELIDE-NOTREE: no matching function for call to 'foo23'
> +// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'D23<D23<char>>' to 'D23<const D23<int>>' for 1st argument
> +// CHECK-NOELIDE-NOTREE: no matching function for call to 'foo23'
> +// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'D23<char>' to 'D23<A23<>>' for 1st argument
> +// CHECK-ELIDE-TREE: no matching function for call to 'foo23'
> +// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
> +// CHECK-ELIDE-TREE: D23<
> +// CHECK-ELIDE-TREE: [(no qualifiers) != const] D23<
> +// CHECK-ELIDE-TREE: [char != int]>>
> +// CHECK-ELIDE-TREE: no matching function for call to 'foo23'
> +// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
> +// CHECK-ELIDE-TREE: D23<
> +// CHECK-ELIDE-TREE: [char != A23<>]>
> +// CHECK-NOELIDE-TREE: no matching function for call to 'foo23'
> +// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
> +// CHECK-NOELIDE-TREE: D23<
> +// CHECK-NOELIDE-TREE: [(no qualifiers) != const] D23<
> +// CHECK-NOELIDE-TREE: [char != int]>>
> +// CHECK-NOELIDE-TREE: no matching function for call to 'foo23'
> +// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
> +// CHECK-NOELIDE-TREE: D23<
> +// CHECK-NOELIDE-TREE: [char != A23<>]>
> +
> // CHECK-ELIDE-NOTREE: {{[0-9]*}} errors generated.
> // CHECK-NOELIDE-NOTREE: {{[0-9]*}} errors generated.
> // CHECK-ELIDE-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