maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/test/Misc/diag-template-diffing.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

1500 lines
73 KiB
C++
Raw Normal View History

Add 'not' to commands that are expected to fail. This is at least good documentation, but also opens the possibility of using pipefail. llvm-svn: 185652
2013-07-05 00:16:58 +08:00
// RUN: not %clang_cc1 -fsyntax-only %s -std=c++11 2>&1 | FileCheck %s -check-prefix=CHECK-ELIDE-NOTREE
// RUN: not %clang_cc1 -fsyntax-only %s -fno-elide-type -std=c++11 2>&1 | FileCheck %s -check-prefix=CHECK-NOELIDE-NOTREE
// RUN: not %clang_cc1 -fsyntax-only %s -fdiagnostics-show-template-tree -std=c++11 2>&1 | FileCheck %s -check-prefix=CHECK-ELIDE-TREE
// RUN: not %clang_cc1 -fsyntax-only %s -fno-elide-type -fdiagnostics-show-template-tree -std=c++11 2>&1 | FileCheck %s -check-prefix=CHECK-NOELIDE-TREE
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// 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'
Print nested name specifiers for typedefs and type aliases Printing typedefs or type aliases using clang_getTypeSpelling() is missing the namespace they are defined in. This is in contrast to other types that always yield the full typename including namespaces. Patch by Michael Reiher! Differential Revision: https://reviews.llvm.org/D29944 llvm-svn: 297465
2017-03-10 23:04:58 +08:00
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<std::string>' to 'vector<string>' for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-NOELIDE-NOTREE: no matching function for call to 'f'
Print nested name specifiers for typedefs and type aliases Printing typedefs or type aliases using clang_getTypeSpelling() is missing the namespace they are defined in. This is in contrast to other types that always yield the full typename including namespaces. Patch by Michael Reiher! Differential Revision: https://reviews.llvm.org/D29944 llvm-svn: 297465
2017-03-10 23:04:58 +08:00
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<std::string>' to 'vector<string>' for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-ELIDE-TREE: no matching function for call to 'f'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-ELIDE-TREE: vector<
Print nested name specifiers for typedefs and type aliases Printing typedefs or type aliases using clang_getTypeSpelling() is missing the namespace they are defined in. This is in contrast to other types that always yield the full typename including namespaces. Patch by Michael Reiher! Differential Revision: https://reviews.llvm.org/D29944 llvm-svn: 297465
2017-03-10 23:04:58 +08:00
// CHECK-ELIDE-TREE: [std::string != string]>
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-NOELIDE-TREE: no matching function for call to 'f'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-NOELIDE-TREE: vector<
Print nested name specifiers for typedefs and type aliases Printing typedefs or type aliases using clang_getTypeSpelling() is missing the namespace they are defined in. This is in contrast to other types that always yield the full typename including namespaces. Patch by Michael Reiher! Differential Revision: https://reviews.llvm.org/D29944 llvm-svn: 297465
2017-03-10 23:04:58 +08:00
// CHECK-NOELIDE-TREE: [std::string != string]>
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
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'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// 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'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// 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'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// 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'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// 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'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-ELIDE-TREE: I3<
// CHECK-ELIDE-TREE: [&V3 != &V1]
// CHECK-ELIDE-TREE: [...]>
// CHECK-NOELIDE-TREE: no matching function for call to 'set3'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// 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'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// 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'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// 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'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// 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'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// 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'
Only print a semicolon after "no known conversion for Nth argument" if there is a following clause. llvm-svn: 159369
2012-06-29 03:20:41 +08:00
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'class7<&b7>' to 'class7<&a7>' for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-ELIDE-NOTREE: no matching function for call to 'set7'
Only print a semicolon after "no known conversion for Nth argument" if there is a following clause. llvm-svn: 159369
2012-06-29 03:20:41 +08:00
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'class7<c7>' to 'class7<&a7>' for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-ELIDE-NOTREE: no matching function for call to 'set7'
Only print a semicolon after "no known conversion for Nth argument" if there is a following clause. llvm-svn: 159369
2012-06-29 03:20:41 +08:00
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'class7<nullptr>' to 'class7<&a7>' for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set7'
Only print a semicolon after "no known conversion for Nth argument" if there is a following clause. llvm-svn: 159369
2012-06-29 03:20:41 +08:00
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'class7<&b7>' to 'class7<&a7>' for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set7'
Only print a semicolon after "no known conversion for Nth argument" if there is a following clause. llvm-svn: 159369
2012-06-29 03:20:41 +08:00
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'class7<c7>' to 'class7<&a7>' for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set7'
Only print a semicolon after "no known conversion for Nth argument" if there is a following clause. llvm-svn: 159369
2012-06-29 03:20:41 +08:00
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'class7<nullptr>' to 'class7<&a7>' for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-ELIDE-TREE: no matching function for call to 'set7'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-ELIDE-TREE: class7<
// CHECK-ELIDE-TREE: [&b7 != &a7]>
// CHECK-ELIDE-TREE: no matching function for call to 'set7'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-ELIDE-TREE: class7<
// CHECK-ELIDE-TREE: [c7 != &a7]>
// CHECK-ELIDE-TREE: no matching function for call to 'set7'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-ELIDE-TREE: class7<
// CHECK-ELIDE-TREE: [nullptr != &a7]>
// CHECK-NOELIDE-TREE: no matching function for call to 'set7'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-NOELIDE-TREE: class7<
// CHECK-NOELIDE-TREE: [&b7 != &a7]>
// CHECK-NOELIDE-TREE: no matching function for call to 'set7'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-NOELIDE-TREE: class7<
// CHECK-NOELIDE-TREE: [c7 != &a7]>
// CHECK-NOELIDE-TREE: no matching function for call to 'set7'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// 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'
Only print a semicolon after "no known conversion for Nth argument" if there is a following clause. llvm-svn: 159369
2012-06-29 03:20:41 +08:00
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'S8<[2 * ...], char>' to 'S8<[2 * ...], double>' for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-NOELIDE-NOTREE: no matching function for call to 'f8'
Only print a semicolon after "no known conversion for Nth argument" if there is a following clause. llvm-svn: 159369
2012-06-29 03:20:41 +08:00
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'S8<int, char, char>' to 'S8<int, char, double>' for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-ELIDE-TREE: no matching function for call to 'f8'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-ELIDE-TREE: S8<
// CHECK-ELIDE-TREE: [2 * ...],
// CHECK-ELIDE-TREE: [char != double]>
// CHECK-NOELIDE-TREE: no matching function for call to 'f8'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// 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'
Only print a semicolon after "no known conversion for Nth argument" if there is a following clause. llvm-svn: 159369
2012-06-29 03:20:41 +08:00
// 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
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-NOELIDE-NOTREE: no matching function for call to 'f9'
Only print a semicolon after "no known conversion for Nth argument" if there is a following clause. llvm-svn: 159369
2012-06-29 03:20:41 +08:00
// 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
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-ELIDE-TREE: no matching function for call to 'f9'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// 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'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// 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'
Only print a semicolon after "no known conversion for Nth argument" if there is a following clause. llvm-svn: 159369
2012-06-29 03:20:41 +08:00
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'class_types<[...], (no argument)>' to 'class_types<[...], int>' for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-ELIDE-NOTREE: no matching function for call to 'set10'
Only print a semicolon after "no known conversion for Nth argument" if there is a following clause. llvm-svn: 159369
2012-06-29 03:20:41 +08:00
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'class_types<[2 * ...], int>' to 'class_types<[2 * ...], (no argument)>' for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set10'
Only print a semicolon after "no known conversion for Nth argument" if there is a following clause. llvm-svn: 159369
2012-06-29 03:20:41 +08:00
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'class_types<int, (no argument)>' to 'class_types<int, int>' for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set10'
Only print a semicolon after "no known conversion for Nth argument" if there is a following clause. llvm-svn: 159369
2012-06-29 03:20:41 +08:00
// 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
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-ELIDE-TREE: no matching function for call to 'set10'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-ELIDE-TREE: class_types<
// CHECK-ELIDE-TREE: [...],
// CHECK-ELIDE-TREE: [(no argument) != int]>
// CHECK-ELIDE-TREE: no matching function for call to 'set10'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// 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'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// 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'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// 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'
Only print a semicolon after "no known conversion for Nth argument" if there is a following clause. llvm-svn: 159369
2012-06-29 03:20:41 +08:00
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'class_ints<1, (no argument)>' to 'class_ints<2, 3>' for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-ELIDE-NOTREE: no matching function for call to 'set11'
Only print a semicolon after "no known conversion for Nth argument" if there is a following clause. llvm-svn: 159369
2012-06-29 03:20:41 +08:00
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'class_ints<0, [...], 6>' to 'class_ints<2, [...], (no argument)>' for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set11'
Only print a semicolon after "no known conversion for Nth argument" if there is a following clause. llvm-svn: 159369
2012-06-29 03:20:41 +08:00
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'class_ints<1, (no argument)>' to 'class_ints<2, 3>' for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set11'
Only print a semicolon after "no known conversion for Nth argument" if there is a following clause. llvm-svn: 159369
2012-06-29 03:20:41 +08:00
// 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
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-ELIDE-TREE: no matching function for call to 'set11'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// 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'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// 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'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// 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'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// 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'
Only print a semicolon after "no known conversion for Nth argument" if there is a following clause. llvm-svn: 159369
2012-06-29 03:20:41 +08:00
// 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
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-ELIDE-NOTREE: no matching function for call to 'set12'
Only print a semicolon after "no known conversion for Nth argument" if there is a following clause. llvm-svn: 159369
2012-06-29 03:20:41 +08:00
// 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
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set12'
Only print a semicolon after "no known conversion for Nth argument" if there is a following clause. llvm-svn: 159369
2012-06-29 03:20:41 +08:00
// 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
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set12'
Only print a semicolon after "no known conversion for Nth argument" if there is a following clause. llvm-svn: 159369
2012-06-29 03:20:41 +08:00
// 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
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-ELIDE-TREE: no matching function for call to 'set12'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// 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'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// 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'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// 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'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// 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>());
[c++20] Implement P0846R0: allow (ADL-only) calls to template-ids whose template name is not visible to unqualified lookup. In order to support this without a severe degradation in our ability to diagnose typos in template names, this change significantly restructures the way we handle template-id-shaped syntax for which lookup of the template name finds nothing. Instead of eagerly diagnosing an undeclared template name, we now form a placeholder template-name representing a name that is known to not find any templates. When the parser sees such a name, it attempts to disambiguate whether we have a less-than comparison or a template-id. Any diagnostics or typo-correction for the name are delayed until its point of use. The upshot should be a small improvement of our diagostic quality overall: we now take more syntactic context into account when trying to resolve an undeclared identifier on the left hand side of a '<'. In fact, this works well enough that the backwards-compatible portion (for an undeclared identifier rather than a lookup that finds functions but no function templates) is enabled in all language modes. llvm-svn: 360308
2019-05-09 11:31:27 +08:00
set13(class_ptrs<&a13, &b13, &d13>());
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
}
// CHECK-ELIDE-NOTREE: no matching function for call to 'set13'
Only print a semicolon after "no known conversion for Nth argument" if there is a following clause. llvm-svn: 159369
2012-06-29 03:20:41 +08:00
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'class_ptrs<&c13, (no argument)>' to 'class_ptrs<&a13, &b13>' for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-ELIDE-NOTREE: no matching function for call to 'set13'
Only print a semicolon after "no known conversion for Nth argument" if there is a following clause. llvm-svn: 159369
2012-06-29 03:20:41 +08:00
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'class_ptrs<[2 * ...], &d13>' to 'class_ptrs<[2 * ...], (no argument)>' for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set13'
Only print a semicolon after "no known conversion for Nth argument" if there is a following clause. llvm-svn: 159369
2012-06-29 03:20:41 +08:00
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'class_ptrs<&c13, (no argument)>' to 'class_ptrs<&a13, &b13>' for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set13'
Only print a semicolon after "no known conversion for Nth argument" if there is a following clause. llvm-svn: 159369
2012-06-29 03:20:41 +08:00
// 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
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-ELIDE-TREE: no matching function for call to 'set13'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// 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'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// 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'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// 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'
Fix typos from r159463 and update tests. Added Matt Beaumont-Gay's suggestion to improve wording of a diagnostic message. llvm-svn: 159473
2012-06-30 07:11:10 +08:00
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// CHECK-NOELIDE-TREE: class_ptrs<
// CHECK-NOELIDE-TREE: &a13,
// CHECK-NOELIDE-TREE: &b13,
// CHECK-NOELIDE-TREE: [&d13 != (no argument)]>
Teach Type::getAs<TemplateSpecializationType> that a TemplateSpecializationType for a type alias template can appear as sugar at any level of desugaring, just like a TypedefType. llvm-svn: 164655
2012-09-26 10:18:13 +08:00
template<typename T> struct s14 {};
template<typename T> using a14 = s14<T>;
typedef a14<int> b14;
template<typename T> using c14 = b14;
int f14(c14<int>);
int k14 = f14(a14<char>());
// CHECK-ELIDE-NOTREE: no matching function for call to 'f14'
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'a14<char>' to 'a14<int>' for 1st argument
// CHECK-NOELIDE-NOTREE: no matching function for call to 'f14'
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'a14<char>' to 'a14<int>' for 1st argument
// CHECK-ELIDE-TREE: no matching function for call to 'f14'
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
// CHECK-ELIDE-TREE: a14<
// CHECK-ELIDE-TREE: [char != int]>
// CHECK-NOELIDE-TREE: no matching function for call to 'f14'
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
// CHECK-NOELIDE-TREE: a14<
// CHECK-NOELIDE-TREE: [char != int]>
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
Update template type diffing to handle qualifiers. Differing qualifiers will now be printed with highlighting. llvm-svn: 164843
2012-09-29 04:32:51 +08:00
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'
Template Type Diffing change When all the arguments of a template are elided, print "A<...>" instead of "A<[2 * ...]>". Also remove comment fragment that means nothing. llvm-svn: 259445
2016-02-02 08:36:59 +08:00
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<const vector<...>>' to 'vector<vector<...>>' for 1st argument
Update template type diffing to handle qualifiers. Differing qualifiers will now be printed with highlighting. llvm-svn: 164843
2012-09-29 04:32:51 +08:00
// 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<
Template Type Diffing change When all the arguments of a template are elided, print "A<...>" instead of "A<[2 * ...]>". Also remove comment fragment that means nothing. llvm-svn: 259445
2016-02-02 08:36:59 +08:00
// CHECK-ELIDE-TREE: [const != (no qualifiers)] vector<...>>
Update template type diffing to handle qualifiers. Differing qualifiers will now be printed with highlighting. llvm-svn: 164843
2012-09-29 04:32:51 +08:00
// 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'
Template Type Diffing change When all the arguments of a template are elided, print "A<...>" instead of "A<[2 * ...]>". Also remove comment fragment that means nothing. llvm-svn: 259445
2016-02-02 08:36:59 +08:00
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<vector<...>>' to 'vector<const vector<...>>' for 1st argument
Update template type diffing to handle qualifiers. Differing qualifiers will now be printed with highlighting. llvm-svn: 164843
2012-09-29 04:32:51 +08:00
// 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<
Template Type Diffing change When all the arguments of a template are elided, print "A<...>" instead of "A<[2 * ...]>". Also remove comment fragment that means nothing. llvm-svn: 259445
2016-02-02 08:36:59 +08:00
// CHECK-ELIDE-TREE: [(no qualifiers) != const] vector<...>>
Update template type diffing to handle qualifiers. Differing qualifiers will now be printed with highlighting. llvm-svn: 164843
2012-09-29 04:32:51 +08:00
// 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'
Template Type Diffing change When all the arguments of a template are elided, print "A<...>" instead of "A<[2 * ...]>". Also remove comment fragment that means nothing. llvm-svn: 259445
2016-02-02 08:36:59 +08:00
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<const vector<...>>' to 'vector<volatile vector<...>>' for 1st argument
Update template type diffing to handle qualifiers. Differing qualifiers will now be printed with highlighting. llvm-svn: 164843
2012-09-29 04:32:51 +08:00
// 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<
Template Type Diffing change When all the arguments of a template are elided, print "A<...>" instead of "A<[2 * ...]>". Also remove comment fragment that means nothing. llvm-svn: 259445
2016-02-02 08:36:59 +08:00
// CHECK-ELIDE-TREE: [const != volatile] vector<...>>
Update template type diffing to handle qualifiers. Differing qualifiers will now be printed with highlighting. llvm-svn: 164843
2012-09-29 04:32:51 +08:00
// 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'
Template Type Diffing change When all the arguments of a template are elided, print "A<...>" instead of "A<[2 * ...]>". Also remove comment fragment that means nothing. llvm-svn: 259445
2016-02-02 08:36:59 +08:00
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<const vector<...>>' to 'vector<const volatile vector<...>>' for 1st argument
Update template type diffing to handle qualifiers. Differing qualifiers will now be printed with highlighting. llvm-svn: 164843
2012-09-29 04:32:51 +08:00
// 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<
Template Type Diffing change When all the arguments of a template are elided, print "A<...>" instead of "A<[2 * ...]>". Also remove comment fragment that means nothing. llvm-svn: 259445
2016-02-02 08:36:59 +08:00
// CHECK-ELIDE-TREE: [const != const volatile] vector<...>>
Update template type diffing to handle qualifiers. Differing qualifiers will now be printed with highlighting. llvm-svn: 164843
2012-09-29 04:32:51 +08:00
// 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'
Template Type Diffing change When all the arguments of a template are elided, print "A<...>" instead of "A<[2 * ...]>". Also remove comment fragment that means nothing. llvm-svn: 259445
2016-02-02 08:36:59 +08:00
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<U21<...>>' to 'vector<const U21<...>>' for 1st argument
Update template type diffing to handle qualifiers. Differing qualifiers will now be printed with highlighting. llvm-svn: 164843
2012-09-29 04:32:51 +08:00
// 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<
Template Type Diffing change When all the arguments of a template are elided, print "A<...>" instead of "A<[2 * ...]>". Also remove comment fragment that means nothing. llvm-svn: 259445
2016-02-02 08:36:59 +08:00
// CHECK-ELIDE-TREE: [(no qualifiers) != const] U21<...>>
Update template type diffing to handle qualifiers. Differing qualifiers will now be printed with highlighting. llvm-svn: 164843
2012-09-29 04:32:51 +08:00
// 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'
Template Type Diffing change When all the arguments of a template are elided, print "A<...>" instead of "A<[2 * ...]>". Also remove comment fragment that means nothing. llvm-svn: 259445
2016-02-02 08:36:59 +08:00
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<U22<...>>' to 'vector<const U22<...>>' for 1st argument
Update template type diffing to handle qualifiers. Differing qualifiers will now be printed with highlighting. llvm-svn: 164843
2012-09-29 04:32:51 +08:00
// 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<
Template Type Diffing change When all the arguments of a template are elided, print "A<...>" instead of "A<[2 * ...]>". Also remove comment fragment that means nothing. llvm-svn: 259445
2016-02-02 08:36:59 +08:00
// CHECK-ELIDE-TREE: [(no qualifiers) != const] U22<...>>
Update template type diffing to handle qualifiers. Differing qualifiers will now be printed with highlighting. llvm-svn: 164843
2012-09-29 04:32:51 +08:00
// 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<>]>
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-02 05:29:28 +08:00
namespace PR14015 {
template <unsigned N> class Foo1 {};
template <unsigned N = 2> class Foo2 {};
template <unsigned ...N> class Foo3 {};
void Play1() {
Foo1<1> F1;
Foo1<2> F2, F3;
F2 = F1;
F1 = F2;
F2 = F3;
F3 = F2;
}
// CHECK-ELIDE-NOTREE: no viable overloaded '='
Strip off local qualifiers when converting from RecordType to TemplateSpecializationType during template type diffing. This allows the correct printing of diffing qualifiers on templates. llvm-svn: 177809
2013-03-23 09:38:36 +08:00
// CHECK-ELIDE-NOTREE: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'Foo1<1>' to 'const Foo1<2>' for 1st argument
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-02 05:29:28 +08:00
// CHECK-ELIDE-NOTREE: candidate function (the implicit move assignment operator) not viable: no known conversion from 'Foo1<1>' to 'Foo1<2>' for 1st argument
// CHECK-ELIDE-NOTREE: no viable overloaded '='
Strip off local qualifiers when converting from RecordType to TemplateSpecializationType during template type diffing. This allows the correct printing of diffing qualifiers on templates. llvm-svn: 177809
2013-03-23 09:38:36 +08:00
// CHECK-ELIDE-NOTREE: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'Foo1<2>' to 'const Foo1<1>' for 1st argument
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-02 05:29:28 +08:00
// CHECK-ELIDE-NOTREE: candidate function (the implicit move assignment operator) not viable: no known conversion from 'Foo1<2>' to 'Foo1<1>' for 1st argument
// CHECK-NOELIDE-NOTREE: no viable overloaded '='
Strip off local qualifiers when converting from RecordType to TemplateSpecializationType during template type diffing. This allows the correct printing of diffing qualifiers on templates. llvm-svn: 177809
2013-03-23 09:38:36 +08:00
// CHECK-NOELIDE-NOTREE: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'Foo1<1>' to 'const Foo1<2>' for 1st argument
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-02 05:29:28 +08:00
// CHECK-NOELIDE-NOTREE: candidate function (the implicit move assignment operator) not viable: no known conversion from 'Foo1<1>' to 'Foo1<2>' for 1st argument
// CHECK-NOELIDE-NOTREE: no viable overloaded '='
Strip off local qualifiers when converting from RecordType to TemplateSpecializationType during template type diffing. This allows the correct printing of diffing qualifiers on templates. llvm-svn: 177809
2013-03-23 09:38:36 +08:00
// CHECK-NOELIDE-NOTREE: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'Foo1<2>' to 'const Foo1<1>' for 1st argument
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-02 05:29:28 +08:00
// CHECK-NOELIDE-NOTREE: candidate function (the implicit move assignment operator) not viable: no known conversion from 'Foo1<2>' to 'Foo1<1>' for 1st argument
// CHECK-ELIDE-TREE: no viable overloaded '='
// CHECK-ELIDE-TREE: candidate function (the implicit copy assignment operator) not viable: no known conversion from argument type to parameter type for 1st argument
Strip off local qualifiers when converting from RecordType to TemplateSpecializationType during template type diffing. This allows the correct printing of diffing qualifiers on templates. llvm-svn: 177809
2013-03-23 09:38:36 +08:00
// CHECK-ELIDE-TREE: [(no qualifiers) != const] Foo1<
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-02 05:29:28 +08:00
// CHECK-ELIDE-TREE: [1 != 2]>
// CHECK-ELIDE-TREE: candidate function (the implicit move assignment operator) not viable: no known conversion from argument type to parameter type for 1st argument
// CHECK-ELIDE-TREE: Foo1<
// CHECK-ELIDE-TREE: [1 != 2]>
// CHECK-ELIDE-TREE: no viable overloaded '='
// CHECK-ELIDE-TREE: candidate function (the implicit copy assignment operator) not viable: no known conversion from argument type to parameter type for 1st argument
Strip off local qualifiers when converting from RecordType to TemplateSpecializationType during template type diffing. This allows the correct printing of diffing qualifiers on templates. llvm-svn: 177809
2013-03-23 09:38:36 +08:00
// CHECK-ELIDE-TREE: [(no qualifiers) != const] Foo1<
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-02 05:29:28 +08:00
// CHECK-ELIDE-TREE: [2 != 1]>
// CHECK-ELIDE-TREE: candidate function (the implicit move assignment operator) not viable: no known conversion from argument type to parameter type for 1st argument
// CHECK-ELIDE-TREE: Foo1<
// CHECK-ELIDE-TREE: [2 != 1]>
// CHECK-NOELIDE-TREE: no viable overloaded '='
// CHECK-NOELIDE-TREE: candidate function (the implicit copy assignment operator) not viable: no known conversion from argument type to parameter type for 1st argument
Strip off local qualifiers when converting from RecordType to TemplateSpecializationType during template type diffing. This allows the correct printing of diffing qualifiers on templates. llvm-svn: 177809
2013-03-23 09:38:36 +08:00
// CHECK-NOELIDE-TREE: [(no qualifiers) != const] Foo1<
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-02 05:29:28 +08:00
// CHECK-NOELIDE-TREE: [1 != 2]>
// CHECK-NOELIDE-TREE: candidate function (the implicit move assignment operator) not viable: no known conversion from argument type to parameter type for 1st argument
// CHECK-NOELIDE-TREE: Foo1<
// CHECK-NOELIDE-TREE: [1 != 2]>
// CHECK-NOELIDE-TREE: no viable overloaded '='
// CHECK-NOELIDE-TREE: candidate function (the implicit copy assignment operator) not viable: no known conversion from argument type to parameter type for 1st argument
Strip off local qualifiers when converting from RecordType to TemplateSpecializationType during template type diffing. This allows the correct printing of diffing qualifiers on templates. llvm-svn: 177809
2013-03-23 09:38:36 +08:00
// CHECK-NOELIDE-TREE: [(no qualifiers) != const] Foo1<
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-02 05:29:28 +08:00
// CHECK-NOELIDE-TREE: [2 != 1]>
// CHECK-NOELIDE-TREE: candidate function (the implicit move assignment operator) not viable: no known conversion from argument type to parameter type for 1st argument
// CHECK-NOELIDE-TREE: Foo1<
// CHECK-NOELIDE-TREE: [2 != 1]>
void Play2() {
Foo2<1> F1;
Foo2<> F2, F3;
F2 = F1;
F1 = F2;
F2 = F3;
F3 = F2;
}
// CHECK-ELIDE-NOTREE: no viable overloaded '='
Strip off local qualifiers when converting from RecordType to TemplateSpecializationType during template type diffing. This allows the correct printing of diffing qualifiers on templates. llvm-svn: 177809
2013-03-23 09:38:36 +08:00
// CHECK-ELIDE-NOTREE: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'Foo2<1>' to 'const Foo2<2>' for 1st argument
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-02 05:29:28 +08:00
// CHECK-ELIDE-NOTREE: candidate function (the implicit move assignment operator) not viable: no known conversion from 'Foo2<1>' to 'Foo2<2>' for 1st argument
// CHECK-ELIDE-NOTREE: no viable overloaded '='
Strip off local qualifiers when converting from RecordType to TemplateSpecializationType during template type diffing. This allows the correct printing of diffing qualifiers on templates. llvm-svn: 177809
2013-03-23 09:38:36 +08:00
// CHECK-ELIDE-NOTREE: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'Foo2<(default) 2>' to 'const Foo2<1>' for 1st argument
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-02 05:29:28 +08:00
// CHECK-ELIDE-NOTREE: candidate function (the implicit move assignment operator) not viable: no known conversion from 'Foo2<(default) 2>' to 'Foo2<1>' for 1st argument
// CHECK-NOELIDE-NOTREE: no viable overloaded '='
Strip off local qualifiers when converting from RecordType to TemplateSpecializationType during template type diffing. This allows the correct printing of diffing qualifiers on templates. llvm-svn: 177809
2013-03-23 09:38:36 +08:00
// CHECK-NOELIDE-NOTREE: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'Foo2<1>' to 'const Foo2<2>' for 1st argument
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-02 05:29:28 +08:00
// CHECK-NOELIDE-NOTREE: candidate function (the implicit move assignment operator) not viable: no known conversion from 'Foo2<1>' to 'Foo2<2>' for 1st argument
// CHECK-NOELIDE-NOTREE: no viable overloaded '='
Strip off local qualifiers when converting from RecordType to TemplateSpecializationType during template type diffing. This allows the correct printing of diffing qualifiers on templates. llvm-svn: 177809
2013-03-23 09:38:36 +08:00
// CHECK-NOELIDE-NOTREE: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'Foo2<(default) 2>' to 'const Foo2<1>' for 1st argument
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-02 05:29:28 +08:00
// CHECK-NOELIDE-NOTREE: candidate function (the implicit move assignment operator) not viable: no known conversion from 'Foo2<(default) 2>' to 'Foo2<1>' for 1st argument
// CHECK-ELIDE-TREE: no viable overloaded '='
// CHECK-ELIDE-TREE: candidate function (the implicit copy assignment operator) not viable: no known conversion from argument type to parameter type for 1st argument
Strip off local qualifiers when converting from RecordType to TemplateSpecializationType during template type diffing. This allows the correct printing of diffing qualifiers on templates. llvm-svn: 177809
2013-03-23 09:38:36 +08:00
// CHECK-ELIDE-TREE: [(no qualifiers) != const] Foo2<
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-02 05:29:28 +08:00
// CHECK-ELIDE-TREE: [1 != 2]>
// CHECK-ELIDE-TREE: candidate function (the implicit move assignment operator) not viable: no known conversion from argument type to parameter type for 1st argument
// CHECK-ELIDE-TREE: Foo2<
// CHECK-ELIDE-TREE: [1 != 2]>
// CHECK-ELIDE-TREE: no viable overloaded '='
// CHECK-ELIDE-TREE: candidate function (the implicit copy assignment operator) not viable: no known conversion from argument type to parameter type for 1st argument
Strip off local qualifiers when converting from RecordType to TemplateSpecializationType during template type diffing. This allows the correct printing of diffing qualifiers on templates. llvm-svn: 177809
2013-03-23 09:38:36 +08:00
// CHECK-ELIDE-TREE: [(no qualifiers) != const] Foo2<
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-02 05:29:28 +08:00
// CHECK-ELIDE-TREE: [(default) 2 != 1]>
// CHECK-ELIDE-TREE: candidate function (the implicit move assignment operator) not viable: no known conversion from argument type to parameter type for 1st argument
// CHECK-ELIDE-TREE: Foo2<
// CHECK-ELIDE-TREE: [(default) 2 != 1]>
// CHECK-NOELIDE-TREE: no viable overloaded '='
// CHECK-NOELIDE-TREE: candidate function (the implicit copy assignment operator) not viable: no known conversion from argument type to parameter type for 1st argument
Strip off local qualifiers when converting from RecordType to TemplateSpecializationType during template type diffing. This allows the correct printing of diffing qualifiers on templates. llvm-svn: 177809
2013-03-23 09:38:36 +08:00
// CHECK-NOELIDE-TREE: [(no qualifiers) != const] Foo2<
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-02 05:29:28 +08:00
// CHECK-NOELIDE-TREE: [1 != 2]>
// CHECK-NOELIDE-TREE: candidate function (the implicit move assignment operator) not viable: no known conversion from argument type to parameter type for 1st argument
// CHECK-NOELIDE-TREE: Foo2<
// CHECK-NOELIDE-TREE: [1 != 2]>
// CHECK-NOELIDE-TREE: no viable overloaded '='
// CHECK-NOELIDE-TREE: candidate function (the implicit copy assignment operator) not viable: no known conversion from argument type to parameter type for 1st argument
Strip off local qualifiers when converting from RecordType to TemplateSpecializationType during template type diffing. This allows the correct printing of diffing qualifiers on templates. llvm-svn: 177809
2013-03-23 09:38:36 +08:00
// CHECK-NOELIDE-TREE: [(no qualifiers) != const] Foo2<
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-02 05:29:28 +08:00
// CHECK-NOELIDE-TREE: [(default) 2 != 1]>
// CHECK-NOELIDE-TREE: candidate function (the implicit move assignment operator) not viable: no known conversion from argument type to parameter type for 1st argument
// CHECK-NOELIDE-TREE: Foo2<
// CHECK-NOELIDE-TREE: [(default) 2 != 1]>
void Play3() {
Foo3<1> F1;
Foo3<2, 1> F2, F3;
F2 = F1;
F1 = F2;
F2 = F3;
F3 = F2;
}
// CHECK-ELIDE-NOTREE: no viable overloaded '='
Strip off local qualifiers when converting from RecordType to TemplateSpecializationType during template type diffing. This allows the correct printing of diffing qualifiers on templates. llvm-svn: 177809
2013-03-23 09:38:36 +08:00
// CHECK-ELIDE-NOTREE: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'Foo3<1, (no argument)>' to 'const Foo3<2, 1>' for 1st argument
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-02 05:29:28 +08:00
// CHECK-ELIDE-NOTREE: candidate function (the implicit move assignment operator) not viable: no known conversion from 'Foo3<1, (no argument)>' to 'Foo3<2, 1>' for 1st argument
// CHECK-ELIDE-NOTREE: no viable overloaded '='
Strip off local qualifiers when converting from RecordType to TemplateSpecializationType during template type diffing. This allows the correct printing of diffing qualifiers on templates. llvm-svn: 177809
2013-03-23 09:38:36 +08:00
// CHECK-ELIDE-NOTREE: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'Foo3<2, 1>' to 'const Foo3<1, (no argument)>' for 1st argument
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-02 05:29:28 +08:00
// CHECK-ELIDE-NOTREE: candidate function (the implicit move assignment operator) not viable: no known conversion from 'Foo3<2, 1>' to 'Foo3<1, (no argument)>' for 1st argument
// CHECK-NOELIDE-NOTREE: no viable overloaded '='
Strip off local qualifiers when converting from RecordType to TemplateSpecializationType during template type diffing. This allows the correct printing of diffing qualifiers on templates. llvm-svn: 177809
2013-03-23 09:38:36 +08:00
// CHECK-NOELIDE-NOTREE: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'Foo3<1, (no argument)>' to 'const Foo3<2, 1>' for 1st argument
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-02 05:29:28 +08:00
// CHECK-NOELIDE-NOTREE: candidate function (the implicit move assignment operator) not viable: no known conversion from 'Foo3<1, (no argument)>' to 'Foo3<2, 1>' for 1st argument
// CHECK-NOELIDE-NOTREE: no viable overloaded '='
Strip off local qualifiers when converting from RecordType to TemplateSpecializationType during template type diffing. This allows the correct printing of diffing qualifiers on templates. llvm-svn: 177809
2013-03-23 09:38:36 +08:00
// CHECK-NOELIDE-NOTREE: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'Foo3<2, 1>' to 'const Foo3<1, (no argument)>' for 1st argument
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-02 05:29:28 +08:00
// CHECK-NOELIDE-NOTREE: candidate function (the implicit move assignment operator) not viable: no known conversion from 'Foo3<2, 1>' to 'Foo3<1, (no argument)>' for 1st argument
// CHECK-ELIDE-TREE: no viable overloaded '='
// CHECK-ELIDE-TREE: candidate function (the implicit copy assignment operator) not viable: no known conversion from argument type to parameter type for 1st argument
Strip off local qualifiers when converting from RecordType to TemplateSpecializationType during template type diffing. This allows the correct printing of diffing qualifiers on templates. llvm-svn: 177809
2013-03-23 09:38:36 +08:00
// CHECK-ELIDE-TREE: [(no qualifiers) != const] Foo3<
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-02 05:29:28 +08:00
// CHECK-ELIDE-TREE: [1 != 2],
// CHECK-ELIDE-TREE: [(no argument) != 1]>
// CHECK-ELIDE-TREE: candidate function (the implicit move assignment operator) not viable: no known conversion from argument type to parameter type for 1st argument
// CHECK-ELIDE-TREE: Foo3<
// CHECK-ELIDE-TREE: [1 != 2],
// CHECK-ELIDE-TREE: [(no argument) != 1]>
// CHECK-ELIDE-TREE: no viable overloaded '='
// CHECK-ELIDE-TREE: candidate function (the implicit copy assignment operator) not viable: no known conversion from argument type to parameter type for 1st argument
Strip off local qualifiers when converting from RecordType to TemplateSpecializationType during template type diffing. This allows the correct printing of diffing qualifiers on templates. llvm-svn: 177809
2013-03-23 09:38:36 +08:00
// CHECK-ELIDE-TREE: [(no qualifiers) != const] Foo3<
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-02 05:29:28 +08:00
// CHECK-ELIDE-TREE: [2 != 1],
// CHECK-ELIDE-TREE: [1 != (no argument)]>
// CHECK-ELIDE-TREE: candidate function (the implicit move assignment operator) not viable: no known conversion from argument type to parameter type for 1st argument
// CHECK-ELIDE-TREE: Foo3<
// CHECK-ELIDE-TREE: [2 != 1],
// CHECK-ELIDE-TREE: [1 != (no argument)]>
// CHECK-NOELIDE-TREE: no viable overloaded '='
// CHECK-NOELIDE-TREE: candidate function (the implicit copy assignment operator) not viable: no known conversion from argument type to parameter type for 1st argument
Strip off local qualifiers when converting from RecordType to TemplateSpecializationType during template type diffing. This allows the correct printing of diffing qualifiers on templates. llvm-svn: 177809
2013-03-23 09:38:36 +08:00
// CHECK-NOELIDE-TREE: [(no qualifiers) != const] Foo3<
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-02 05:29:28 +08:00
// CHECK-NOELIDE-TREE: [1 != 2],
// CHECK-NOELIDE-TREE: [(no argument) != 1]>
// CHECK-NOELIDE-TREE: candidate function (the implicit move assignment operator) not viable: no known conversion from argument type to parameter type for 1st argument
// CHECK-NOELIDE-TREE: Foo3<
// CHECK-NOELIDE-TREE: [1 != 2],
// CHECK-NOELIDE-TREE: [(no argument) != 1]>
// CHECK-NOELIDE-TREE: no viable overloaded '='
// CHECK-NOELIDE-TREE: candidate function (the implicit copy assignment operator) not viable: no known conversion from argument type to parameter type for 1st argument
Strip off local qualifiers when converting from RecordType to TemplateSpecializationType during template type diffing. This allows the correct printing of diffing qualifiers on templates. llvm-svn: 177809
2013-03-23 09:38:36 +08:00
// CHECK-NOELIDE-TREE: [(no qualifiers) != const] Foo3<
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-02 05:29:28 +08:00
// CHECK-NOELIDE-TREE: [2 != 1],
// CHECK-NOELIDE-TREE: [1 != (no argument)]>
// CHECK-NOELIDE-TREE: candidate function (the implicit move assignment operator) not viable: no known conversion from argument type to parameter type for 1st argument
// CHECK-NOELIDE-TREE: Foo3<
// CHECK-NOELIDE-TREE: [2 != 1],
// CHECK-NOELIDE-TREE: [1 != (no argument)]>
}
Make template diffing handle integral expressions of various widths correctly. PR14342. llvm-svn: 168005
2012-11-15 07:57:08 +08:00
namespace PR14342 {
template<typename T, short a> struct X {};
X<int, (signed char)-1> x = X<long, -1>();
X<int, 3UL> y = X<int, 2>();
// CHECK-ELIDE-NOTREE: error: no viable conversion from 'X<long, [...]>' to 'X<int, [...]>'
Improve template diffing handling of default integer values. When the template argument is both default and value dependent, the expression retrieved for the default argument cannot be evaluated, thus never matching any argument value. To get the proper value, get the template argument from the desugared template specialization. Also, output the original expression to provide more information about the argument mismatch. llvm-svn: 177209
2013-03-16 07:55:09 +08:00
// CHECK-ELIDE-NOTREE: error: no viable conversion from 'X<[...], 2>' to 'X<[...], 3>'
Make template diffing handle integral expressions of various widths correctly. PR14342. llvm-svn: 168005
2012-11-15 07:57:08 +08:00
}
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-02 05:29:28 +08:00
Fix a crash in diagnostic printing when a template class type is diff'ed against itself. PR14489. llvm-svn: 170474
2012-12-19 07:32:47 +08:00
namespace PR14489 {
// The important thing here is that the diagnostic diffs a template specialization
// with no arguments against itself. (We might need a different test if this
// diagnostic changes).
template<class ...V>
struct VariableList {
void ConnectAllToAll(VariableList<>& params = VariableList<>()) {
}
};
// CHECK-ELIDE-NOTREE: non-const lvalue reference to type 'VariableList<>' cannot bind to a temporary of type 'VariableList<>'
}
Use a safe default width for template-diff'ing integral arguments, in case we can't find an exact width to use. Fixes crash in <rdar://problem/12456626>. llvm-svn: 170951
2012-12-22 07:03:27 +08:00
namespace rdar12456626 {
struct IntWrapper {
typedef int type;
};
template<typename T, typename T::type V>
struct X { };
struct A {
virtual X<IntWrapper, 1> foo();
};
struct B : A {
// CHECK-ELIDE-NOTREE: virtual function 'foo' has a different return type
virtual X<IntWrapper, 2> foo();
};
}
Handle passing non-Qualtypes to %diff better. Instead of asserting, fall back to printing the default case. This is a fix for PR15023. llvm-svn: 173965
2013-01-31 04:04:31 +08:00
namespace PR15023 {
// Don't crash when non-QualTypes are passed to a diff modifier.
template <typename... Args>
void func(void (*func)(Args...), Args...) { }
void bar(int, int &) {
}
void foo(int x) {
func(bar, 1, x)
}
// CHECK-ELIDE-NOTREE: no matching function for call to 'func'
// CHECK-ELIDE-NOTREE: candidate template ignored: deduced conflicting types for parameter 'Args' (<int, int &> vs. <int, int>)
}
When comparing two templates in the template differ, consider them the same if they are actually the same; having the same name isn't enough. Fixes <rdar://problem/12931988>. llvm-svn: 174013
2013-01-31 09:08:35 +08:00
namespace rdar12931988 {
namespace A {
template<typename T> struct X { };
}
namespace B {
template<typename T> struct X { };
}
void foo(A::X<int> &ax, B::X<int> bx) {
// CHECK-ELIDE-NOTREE: no viable overloaded '='
// CHECK-ELIDE-NOTREE: no known conversion from 'B::X<int>' to 'const rdar12931988::A::X<int>'
ax = bx;
}
When comparing two template template arguments in the template differ, consider them the same if they are actually the same; having the same name isn't enough. Similar to r174013, template template arguments were also mistakenly considered the same when they had the same name but were in different namespaces. In addition, when printing template template arguments, use the qualified name if the regular name is the same. llvm-svn: 174029
2013-01-31 10:47:46 +08:00
template<template<typename> class> class Y {};
void bar(Y<A::X> ya, Y<B::X> yb) {
// CHECK-ELIDE-NOTREE: no viable overloaded '='
// CHECK-ELIDE-NOTREE: no known conversion from 'Y<template rdar12931988::B::X>' to 'Y<template rdar12931988::A::X>'
ya = yb;
}
When comparing two templates in the template differ, consider them the same if they are actually the same; having the same name isn't enough. Fixes <rdar://problem/12931988>. llvm-svn: 174013
2013-01-31 09:08:35 +08:00
}
Update template diffing to handle template arguments that are declarations. llvm-svn: 176153
2013-02-27 09:41:53 +08:00
namespace ValueDecl {
int int1, int2, default_int;
template <const int& T = default_int>
struct S {};
typedef S<int1> T1;
typedef S<int2> T2;
typedef S<> TD;
void test() {
T1 t1;
T2 t2;
TD td;
t1 = t2;
// CHECK-ELIDE-NOTREE: no viable overloaded '='
// CHECK-ELIDE-NOTREE: no known conversion from 'S<int2>' to 'S<int1>'
t2 = t1;
// CHECK-ELIDE-NOTREE: no viable overloaded '='
// CHECK-ELIDE-NOTREE: no known conversion from 'S<int1>' to 'S<int2>'
td = t1;
// TODO: Find out why (default) isn't printed on second template.
// CHECK-ELIDE-NOTREE: no viable overloaded '='
// CHECK-ELIDE-NOTREE: no known conversion from 'S<int1>' to 'S<default_int>'
t2 = td;
// CHECK-ELIDE-NOTREE: no viable overloaded '='
// CHECK-ELIDE-NOTREE: no known conversion from 'S<(default) default_int>' to 'S<int2>'
}
}
Fix a crasher in Template Diffing. Value depenedent expressions for default arguments cannot be evaluated. Instead, use the desugared template type to get an argument expression that can be used. This is needed for both integer and declaration arguements. Also, move this common code into a separate function. Patch by Olivier Goffart! llvm-svn: 178609
2013-04-03 10:11:36 +08:00
namespace DependentDefault {
template <typename> struct Trait {
enum { V = 40 };
typedef int Ty;
static int I;
};
int other;
template <typename T, int = Trait<T>::V > struct A {};
template <typename T, typename = Trait<T>::Ty > struct B {};
template <typename T, int& = Trait<T>::I > struct C {};
void test() {
A<int> a1;
A<char> a2;
A<int, 10> a3;
a1 = a2;
// CHECK-ELIDE-NOTREE: no viable overloaded '='
// CHECK-ELIDE-NOTREE: no known conversion from 'A<char, [...]>' to 'A<int, [...]>'
a3 = a1;
// CHECK-ELIDE-NOTREE: no viable overloaded '='
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-15 06:56:39 +08:00
// CHECK-ELIDE-NOTREE: no known conversion from 'A<[...], (default) Trait<T>::V aka 40>' to 'A<[...], 10>'
Fix a crasher in Template Diffing. Value depenedent expressions for default arguments cannot be evaluated. Instead, use the desugared template type to get an argument expression that can be used. This is needed for both integer and declaration arguements. Also, move this common code into a separate function. Patch by Olivier Goffart! llvm-svn: 178609
2013-04-03 10:11:36 +08:00
a2 = a3;
// CHECK-ELIDE-NOTREE: no viable overloaded '='
// CHECK-ELIDE-NOTREE: no known conversion from 'A<int, 10>' to 'A<char, 40>'
B<int> b1;
B<char> b2;
B<int, char> b3;
b1 = b2;
// CHECK-ELIDE-NOTREE: no viable overloaded '='
If a default argument is a dependent type, get the real type from the desugared template. Passing around dependent types can lead to integral arguments that cannot be evaluated. llvm-svn: 186757
2013-07-20 11:49:02 +08:00
// CHECK-ELIDE-NOTREE: no known conversion from 'B<char, [...]>' to 'B<int, [...]>'
Fix a crasher in Template Diffing. Value depenedent expressions for default arguments cannot be evaluated. Instead, use the desugared template type to get an argument expression that can be used. This is needed for both integer and declaration arguements. Also, move this common code into a separate function. Patch by Olivier Goffart! llvm-svn: 178609
2013-04-03 10:11:36 +08:00
b3 = b1;
// CHECK-ELIDE-NOTREE: no viable overloaded '='
If a default argument is a dependent type, get the real type from the desugared template. Passing around dependent types can lead to integral arguments that cannot be evaluated. llvm-svn: 186757
2013-07-20 11:49:02 +08:00
// CHECK-ELIDE-NOTREE: no known conversion from 'B<[...], (default) int>' to 'B<[...], char>'
Fix a crasher in Template Diffing. Value depenedent expressions for default arguments cannot be evaluated. Instead, use the desugared template type to get an argument expression that can be used. This is needed for both integer and declaration arguements. Also, move this common code into a separate function. Patch by Olivier Goffart! llvm-svn: 178609
2013-04-03 10:11:36 +08:00
b2 = b3;
// CHECK-ELIDE-NOTREE: no viable overloaded '='
// CHECK-ELIDE-NOTREE: no known conversion from 'B<int, char>' to 'B<char, int>'
C<int> c1;
C<char> c2;
C<int, other> c3;
c1 = c2;
// CHECK-ELIDE-NOTREE: no viable overloaded '='
// CHECK-ELIDE-NOTREE: no known conversion from 'C<char, (default) I>' to 'C<int, I>'
c3 = c1;
// CHECK-ELIDE-NOTREE: no viable overloaded '='
// CHECK-ELIDE-NOTREE: no known conversion from 'C<[...], (default) I>' to 'C<[...], other>'
c2 = c3;
// CHECK-ELIDE-NOTREE: no viable overloaded '='
// CHECK-ELIDE-NOTREE: no known conversion from 'C<int, other>' to 'C<char, I>'
}
}
Fix a crasher in Template Diffing. When support was added for declaration arguments, the case of variadic declaration arguments was not supported. This patch fixes that problem by not crashing when certain ValueDecl's are null. Patch by Olivier Goffart! llvm-svn: 178610
2013-04-03 10:22:12 +08:00
namespace VariadicDefault {
int i1, i2, i3;
template <int = 5, int...> struct A {};
template <int& = i1, int& ...> struct B {};
template <typename = void, typename...> struct C {};
void test() {
A<> a1;
A<5, 6, 7> a2;
A<1, 2> a3;
a2 = a1;
// CHECK-ELIDE-NOTREE: no viable overloaded '='
// CHECK-ELIDE-NOTREE: no known conversion from 'A<[...], (no argument), (no argument)>' to 'A<[...], 6, 7>'
a3 = a1;
// CHECK-ELIDE-NOTREE: no viable overloaded '='
// CHECK-ELIDE-NOTREE: no known conversion from 'A<(default) 5, (no argument)>' to 'A<1, 2>'
B<> b1;
B<i1, i2, i3> b2;
B<i2, i3> b3;
b2 = b1;
// CHECK-ELIDE-NOTREE: no viable overloaded '='
// CHECK-ELIDE-NOTREE: no known conversion from 'B<[...], (no argument), (no argument)>' to 'B<[...], i2, i3>'
b3 = b1;
// CHECK-ELIDE-NOTREE: no viable overloaded '='
// CHECK-ELIDE-NOTREE: no known conversion from 'B<(default) i1, (no argument)>' to 'B<i2, i3>'
Do not assume the template argument is an integer only because the expressions are integer. It can also be ValueDecl expressions Use the type information from the TemplateParameterList instead Patch by Olivier Goffart! llvm-svn: 178611
2013-04-03 10:31:17 +08:00
B<i1, i2, i3> b4 = b1;
// CHECK-ELIDE-NOTREE: no viable conversion from 'B<[...], (no argument), (no argument)>' to 'B<[...], i2, i3>'
B<i2, i3> b5 = b1;
// CHECK-ELIDE-NOTREE: no viable conversion from 'B<(default) i1, (no argument)>' to 'B<i2, i3>'
Fix a crasher in Template Diffing. When support was added for declaration arguments, the case of variadic declaration arguments was not supported. This patch fixes that problem by not crashing when certain ValueDecl's are null. Patch by Olivier Goffart! llvm-svn: 178610
2013-04-03 10:22:12 +08:00
C<> c1;
C<void, void> c2;
C<char, char> c3;
c2 = c1;
// CHECK-ELIDE-NOTREE: no viable overloaded '='
// CHECK-ELIDE-NOTREE: no known conversion from 'C<[...], (no argument)>' to 'C<[...], void>'
c3 = c1;
// CHECK-ELIDE-NOTREE: no viable overloaded '='
// CHECK-ELIDE-NOTREE: no known conversion from 'C<(default) void, (no argument)>' to 'C<char, char>'
}
}
Fix crash on invalid in template type diffing. This is a fix for PR15895, where Clang will crash when trying to print a template diff and the template uses an address of operator. This resulted from expecting a DeclRefExpr when the Expr could have also been UnaryOperator->DeclRefExpr. llvm-svn: 181365
2013-05-08 05:36:24 +08:00
namespace PointerArguments {
template <int *p> class T {};
template <int* ...> class U {};
int a, b, c;
int z[5];
void test() {
T<&a> ta;
T<z> tz;
T<&b> tb(ta);
// CHECK-ELIDE-NOTREE: no matching constructor for initialization of 'T<&b>'
// CHECK-ELIDE-NOTREE: candidate constructor (the implicit copy constructor) not viable: no known conversion from 'T<&a>' to 'const T<&b>' for 1st argument
T<&c> tc(tz);
// CHECK-ELIDE-NOTREE: no matching constructor for initialization of 'T<&c>'
// CHECK-ELIDE-NOTREE: candidate constructor (the implicit copy constructor) not viable: no known conversion from 'T<z>' to 'const T<&c>' for 1st argument
U<&a, &a> uaa;
U<&b> ub(uaa);
// CHECK-ELIDE-NOTREE: no matching constructor for initialization of 'U<&b>'
// CHECK-ELIDE-NOTREE: candidate constructor (the implicit copy constructor) not viable: no known conversion from 'U<&a, &a>' to 'const U<&b, (no argument)>' for 1st argument
U<&b, &b, &b> ubbb(uaa);
// CHECK-ELIDE-NOTREE: no matching constructor for initialization of 'U<&b, &b, &b>'
// CHECK-ELIDE-NOTREE: candidate constructor (the implicit copy constructor) not viable: no known conversion from 'U<&a, &a, (no argument)>' to 'const U<&b, &b, &b>' for 1st argument
}
}
If a default argument is a dependent type, get the real type from the desugared template. Passing around dependent types can lead to integral arguments that cannot be evaluated. llvm-svn: 186757
2013-07-20 11:49:02 +08:00
namespace DependentInt {
template<int Num> struct INT;
template <class CLASS, class Int_wrapper = INT<CLASS::val> >
struct C;
struct N {
static const int val = 1;
};
template <class M_T>
struct M {};
void test() {
using T1 = M<C<int, INT<0>>>;
using T2 = M<C<N>>;
T2 p;
T1 x = p;
Pass the PrintingPolicy when converting types to strings in template type diffing. This removes extra "struct"/"class" in the type names and gives "bool" instead of "_Bool" for booleans. llvm-svn: 213912
2014-07-25 08:24:02 +08:00
// CHECK-ELIDE-NOTREE: no viable conversion from 'M<C<DependentInt::N, INT<1>>>' to 'M<C<int, INT<0>>>'
If a default argument is a dependent type, get the real type from the desugared template. Passing around dependent types can lead to integral arguments that cannot be evaluated. llvm-svn: 186757
2013-07-20 11:49:02 +08:00
}
}
Fix an edge case in the template differ with default arguments. In the test case one type is coming from a typedef with no default arg, the other has the default arg. Taking the default arg from the typedef crashes, so always use the real template paramter declaration. PR17510. llvm-svn: 192202
2013-10-09 00:58:52 +08:00
namespace PR17510 {
class Atom;
template <typename T> class allocator;
template <typename T, typename A> class vector;
typedef vector<const Atom *, allocator<const Atom *> > AtomVector;
template <typename T, typename A = allocator<const Atom *> > class vector {};
void foo() {
vector<Atom *> v;
AtomVector v2(v);
Pass the PrintingPolicy when converting types to strings in template type diffing. This removes extra "struct"/"class" in the type names and gives "bool" instead of "_Bool" for booleans. llvm-svn: 213912
2014-07-25 08:24:02 +08:00
// CHECK-ELIDE-NOTREE: no known conversion from 'vector<PR17510::Atom *, [...]>' to 'const vector<const PR17510::Atom *, [...]>'
Fix an edge case in the template differ with default arguments. In the test case one type is coming from a typedef with no default arg, the other has the default arg. Taking the default arg from the typedef crashes, so always use the real template paramter declaration. PR17510. llvm-svn: 192202
2013-10-09 00:58:52 +08:00
}
}
PR15677 - Crash in template diffing. Check that expression is evaluatable before evaluating it. llvm-svn: 212090
2014-07-01 12:17:53 +08:00
namespace PR15677 {
template <bool>
struct A{};
template <typename T>
using B = A<T::value>;
template <typename T>
using B = A<!T::value>;
// CHECK-ELIDE-NOTREE: type alias template redefinition with different types ('A<!T::value>' vs 'A<T::value>')
template <int>
struct C{};
template <typename T>
using D = C<T::value>;
template <typename T>
using D = C<T::value + 1>;
// CHECK-ELIDE-NOTREE: type alias template redefinition with different types ('C<T::value + 1>' vs 'C<T::value>')
template <typename T>
using E = C<T::value>;
template <typename T>
using E = C<42>;
// CHECK-ELIDE-NOTREE: type alias template redefinition with different types ('C<42>' vs 'C<T::value>')
template <typename T>
using F = C<T::value>;
template <typename T>
using F = C<21 + 21>;
// CHECK-ELIDE-NOTREE: type alias template redefinition with different types ('C<21 + 21 aka 42>' vs 'C<T::value>')
}
}
Fix a template diffing problem were an '&' is unexpectedly printed in a template argument. llvm-svn: 213609
2014-07-22 11:33:01 +08:00
namespace AddressOf {
template <int*>
struct S {};
template <class T>
struct Wrapper {};
template <class T>
Wrapper<T> MakeWrapper();
More gracefully handle parentheses in templare arguments in template diffing. llvm-svn: 213611
2014-07-22 12:06:54 +08:00
int global, global2;
Fix a template diffing problem were an '&' is unexpectedly printed in a template argument. llvm-svn: 213609
2014-07-22 11:33:01 +08:00
constexpr int * ptr = nullptr;
Wrapper<S<ptr>> W = MakeWrapper<S<&global>>();
// Don't print an extra '&' for 'ptr'
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 09:08:56 +08:00
// CHECK-ELIDE-NOTREE: no viable conversion from 'Wrapper<S<&global>>' to 'Wrapper<S<ptr aka nullptr>>'
More gracefully handle parentheses in templare arguments in template diffing. llvm-svn: 213611
2014-07-22 12:06:54 +08:00
// Handle parens correctly
Fix '&' printing for template arguments in parentheses in template diffing. llvm-svn: 213613
2014-07-22 12:42:15 +08:00
Wrapper<S<(&global2)>> W2 = MakeWrapper<S<&global>>();
// CHECK-ELIDE-NOTREE: no viable conversion from 'Wrapper<S<&global>>' to 'Wrapper<S<&global2>>'
Wrapper<S<&global2>> W3 = MakeWrapper<S<(&global)>>();
// CHECK-ELIDE-NOTREE: no viable conversion from 'Wrapper<S<&global>>' to 'Wrapper<S<&global2>>'
Wrapper<S<(&global2)>> W4 = MakeWrapper<S<(&global)>>();
// CHECK-ELIDE-NOTREE: no viable conversion from 'Wrapper<S<&global>>' to 'Wrapper<S<&global2>>'
Fix a template diffing problem were an '&' is unexpectedly printed in a template argument. llvm-svn: 213609
2014-07-22 11:33:01 +08:00
}
Add support for nullptr template arguments to template type diffing. llvm-svn: 213840
2014-07-24 12:24:50 +08:00
namespace NullPtr {
template <int*, int*>
struct S {};
template <class T>
struct Wrapper {};
template <class T>
Wrapper<T> MakeWrapper();
int global, global2;
constexpr int * ptr = nullptr;
constexpr int * ptr2 = static_cast<int*>(0);
S<&global> s1 = S<&global, ptr>();
S<&global, nullptr> s2 = S<&global, ptr>();
S<&global, nullptr> s3 = S<&global, &global>();
// CHECK-ELIDE-NOTREE: no viable conversion from 'S<[...], &global>' to 'S<[...], nullptr>'
S<&global, ptr> s4 = S<&global, &global>();
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 09:08:56 +08:00
// CHECK-ELIDE-NOTREE: no viable conversion from 'S<[...], &global>' to 'S<[...], ptr aka nullptr>
Add support for nullptr template arguments to template type diffing. llvm-svn: 213840
2014-07-24 12:24:50 +08:00
Wrapper<S<&global, nullptr>> W1 = MakeWrapper<S<&global, ptr>>();
Wrapper<S<&global, static_cast<int*>(0)>> W2 = MakeWrapper<S<&global, ptr>>();
Wrapper<S<&global, nullptr>> W3 = MakeWrapper<S<&global, &global>>();
// CHECK-ELIDE-NOTREE: no viable conversion from 'Wrapper<S<[...], &global>>' to 'Wrapper<S<[...], nullptr>>'
Wrapper<S<&global, ptr>> W4 = MakeWrapper<S<&global, &global>>();
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 09:08:56 +08:00
// CHECK-ELIDE-NOTREE: no viable conversion from 'Wrapper<S<[...], &global>>' to 'Wrapper<S<[...], ptr aka nullptr>>'
Add support for nullptr template arguments to template type diffing. llvm-svn: 213840
2014-07-24 12:24:50 +08:00
Wrapper<S<&global2, ptr>> W5 = MakeWrapper<S<&global, nullptr>>();
// CHECK-ELIDE-NOTREE: no viable conversion from 'Wrapper<S<&global, [...]>>' to 'Wrapper<S<&global2, [...]>>'
Wrapper<S<&global2, nullptr>> W6 = MakeWrapper<S<&global, nullptr>>();
// CHECK-ELIDE-NOTREE: no viable conversion from 'Wrapper<S<&global, [...]>>' to 'Wrapper<S<&global2, [...]>>'
Wrapper<S<&global2, ptr2>> W7 = MakeWrapper<S<&global, nullptr>>();
// CHECK-ELIDE-NOTREE: no viable conversion from 'Wrapper<S<&global, [...]>>' to 'Wrapper<S<&global2, [...]>>'
Wrapper<S<&global2, nullptr>> W8 = MakeWrapper<S<&global, ptr2>>();
// CHECK-ELIDE-NOTREE: no viable conversion from 'Wrapper<S<&global, [...]>>' to 'Wrapper<S<&global2, [...]>>'
Wrapper<S<&global2, ptr>> W9 = MakeWrapper<S<&global, ptr2>>();
// CHECK-ELIDE-NOTREE: no viable conversion from 'Wrapper<S<&global, [...]>>' to 'Wrapper<S<&global2, [...]>>'
Wrapper<S<&global2, ptr2>> W10 = MakeWrapper<S<&global, ptr>>();
// CHECK-ELIDE-NOTREE: no viable conversion from 'Wrapper<S<&global, [...]>>' to 'Wrapper<S<&global2, [...]>>'
Wrapper<S<&global2, static_cast<int *>(0)>> W11 =
MakeWrapper<S<&global, nullptr>>();
// CHECK-ELIDE-NOTREE: no viable conversion from 'Wrapper<S<&global, [...]>>' to 'Wrapper<S<&global2, [...]>>'
Wrapper<S<&global2, nullptr>> W12 =
MakeWrapper<S<&global, static_cast<int *>(0)>>();
// CHECK-ELIDE-NOTREE: no viable conversion from 'Wrapper<S<&global, [...]>>' to 'Wrapper<S<&global2, [...]>>'
Wrapper<S<&global, &global>> W13 = MakeWrapper<S<&global, ptr>>();
Print "(default)" for default template template arguments to match the printing of other types. llvm-svn: 213902
2014-07-25 07:14:16 +08:00
// CHECK-ELIDE-NOTREE: no viable conversion from 'Wrapper<S<[...], nullptr>>' to 'Wrapper<S<[...], &global>>'
Add support for nullptr template arguments to template type diffing. llvm-svn: 213840
2014-07-24 12:24:50 +08:00
Wrapper<S<&global, ptr>> W14 = MakeWrapper<S<&global, &global>>();
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 09:08:56 +08:00
// CHECK-ELIDE-NOTREE: no viable conversion from 'Wrapper<S<[...], &global>>' to 'Wrapper<S<[...], ptr aka nullptr>>'
Add support for nullptr template arguments to template type diffing. llvm-svn: 213840
2014-07-24 12:24:50 +08:00
}
Print "(default)" for default template template arguments to match the printing of other types. llvm-svn: 213902
2014-07-25 07:14:16 +08:00
namespace TemplateTemplateDefault {
template <class> class A{};
template <class> class B{};
template <class> class C{};
template <template <class> class, template <class> class = A>
class T {};
T<A> t1 = T<A, C>();
// CHECK-ELIDE-NOTREE: no viable conversion from 'T<[...], template C>' to 'T<[...], (default) template A>'
T<A, C> t2 = T<A>();
// CHECK-ELIDE-NOTREE: no viable conversion from 'T<[...], (default) template A>' to 'T<[...], template C>'
T<A> t3 = T<B>();
// CHECK-ELIDE-NOTREE: no viable conversion from 'T<template B>' to 'T<template A>'
T<B, C> t4 = T<C, B>();
// CHECK-ELIDE-NOTREE: no viable conversion from 'T<template C, template B>' to 'T<template B, template C>'
T<A, A> t5 = T<B>();
// CHECK-ELIDE-NOTREE: no viable conversion from 'T<template B, [...]>' to 'T<template A, [...]>'
T<B> t6 = T<A, A>();
// CHECK-ELIDE-NOTREE: no viable conversion from 'T<template A, [...]>' to 'T<template B, [...]>'
}
Pass the PrintingPolicy when converting types to strings in template type diffing. This removes extra "struct"/"class" in the type names and gives "bool" instead of "_Bool" for booleans. llvm-svn: 213912
2014-07-25 08:24:02 +08:00
namespace Bool {
template <class> class A{};
A<bool> a1 = A<int>();
// CHECK-ELIDE-NOTREE: no viable conversion from 'A<int>' to 'A<bool>'
A<int> a2 = A<bool>();
// CHECK-ELIDE-NOTREE: no viable conversion from 'A<bool>' to 'A<int>'
}
If a template argument is non-evaluable expression, use the profile ID to see if the two arguments are equal. llvm-svn: 214008
2014-07-26 10:10:52 +08:00
namespace TypeAlias {
template <int, int = 0> class A {};
template <class T> using a = A<T::num, 0>;
template <class T> using a = A<T::num>;
template <class T> using A1 = A<T::num>;
template <class T> using A1 = A<T::num + 0>;
// CHECK-ELIDE-NOTREE: type alias template redefinition with different types ('A<T::num + 0>' vs 'A<T::num>')
template <class T> using A2 = A<1 + T::num>;
template <class T> using A2 = A<T::num + 1>;
// CHECK-ELIDE-NOTREE: type alias template redefinition with different types ('A<T::num + 1>' vs 'A<1 + T::num>')
template <class T> using A3 = A<(T::num)>;
template <class T> using A3 = A<T::num>;
// CHECK-ELIDE-NOTREE: error: type alias template redefinition with different types ('A<T::num>' vs 'A<(T::num)>')
template <class T> using A4 = A<(T::num)>;
template <class T> using A4 = A<((T::num))>;
// CHECK-ELIDE-NOTREE: type alias template redefinition with different types ('A<((T::num))>' vs 'A<(T::num)>')
template <class T> using A5 = A<T::num, 1>;
template <class T> using A5 = A<T::num>;
// CHECK-ELIDE-NOTREE: type alias template redefinition with different types ('A<[...], (default) 0>' vs 'A<[...], 1>')
template <class T> using A6 = A<T::num + 5, 1>;
template <class T> using A6 = A<T::num + 5>;
// CHECK-ELIDE-NOTREE: type alias template redefinition with different types ('A<[...], (default) 0>' vs 'A<[...], 1>')
template <class T> using A7 = A<T::num, 1>;
template <class T> using A7 = A<(T::num)>;
// CHECK-ELIDE-NOTREE: type alias template redefinition with different types ('A<(T::num), (default) 0>' vs 'A<T::num, 1>')
}
When checking the template argument list, use a copy of that list for changes and only update the orginal list on a valid arugment list. When checking an individual expression template argument, and conversions are required, update the expression in the template argument. Since template arguments are speculatively checked, the copying of the template argument list prevents updating the template arguments when the list does not match the template. Additionally, clean up the integer checking code in the template diffing code. The code performs unneccessary conversions from APSInt to APInt. Fixes PR21758. This essentially reverts r224770 to recommits r224667 and r224668 with extra changes to prevent the template instantiation problems seen in PR22006. A test to catch the discovered problem is also added. llvm-svn: 226983
2015-01-24 10:48:32 +08:00
namespace TemplateArgumentImplicitConversion {
template <int X> struct condition {};
struct is_const {
constexpr operator int() const { return 10; }
};
using T = condition<(is_const())>;
void foo(const T &t) {
T &t2 = t;
}
[Sema] Improved diagnostic for qualifiers in reference binding Improved wording and also simplified by using printing method from qualifiers. Differential Revision: https://reviews.llvm.org/D62914 llvm-svn: 364023
2019-06-21 18:50:02 +08:00
// CHECK-ELIDE-NOTREE: binding reference of type 'condition<...>' to value of type 'const condition<...>' drops 'const' qualifier
When checking the template argument list, use a copy of that list for changes and only update the orginal list on a valid arugment list. When checking an individual expression template argument, and conversions are required, update the expression in the template argument. Since template arguments are speculatively checked, the copying of the template argument list prevents updating the template arguments when the list does not match the template. Additionally, clean up the integer checking code in the template diffing code. The code performs unneccessary conversions from APSInt to APInt. Fixes PR21758. This essentially reverts r224770 to recommits r224667 and r224668 with extra changes to prevent the template instantiation problems seen in PR22006. A test to catch the discovered problem is also added. llvm-svn: 226983
2015-01-24 10:48:32 +08:00
}
Update assumption in template diffing about integer template arguments. Fix for PR22017. Integer template arguments are automatically bit extended to the size of the integer type. In template diffing, evaluated expressions were not having their results extending, leading to comparing two APSInt's with different widths. Apply the proper bit extending when evaluating template arguments. This mainly affected bool template arguments. llvm-svn: 230603
2015-02-26 10:40:48 +08:00
namespace BoolArgumentBitExtended {
template <bool B> struct BoolT {};
template <typename T> void foo(T) {}
void test() {
BoolT<false> X;
foo<BoolT<true>>(X);
}
// CHECK-ELIDE-NOTREE: no matching function for call to 'foo'
Fix test failure after r333485. I missed adjusting a test under Misc in the last commit. This patch updates that test. llvm-svn: 333488
2018-05-30 09:22:14 +08:00
// CHECK-ELIDE-NOTREE: candidate function template not viable: no known conversion from 'BoolT<false>' to 'BoolT<true>' for 1st argument
Update assumption in template diffing about integer template arguments. Fix for PR22017. Integer template arguments are automatically bit extended to the size of the integer type. In template diffing, evaluated expressions were not having their results extending, leading to comparing two APSInt's with different widths. Apply the proper bit extending when evaluating template arguments. This mainly affected bool template arguments. llvm-svn: 230603
2015-02-26 10:40:48 +08:00
}
Save the integer type for integral template arguments. Save the integer type when diffing integers in template type diffing. When integers are different sizes, print out the type along with the integer value. Also with the type information, print true and false instead of 1 and 0 for boolean values. llvm-svn: 257861
2016-01-15 10:55:17 +08:00
namespace DifferentIntegralTypes {
template<typename T, T n>
class A{};
void foo() {
A<int, 1> a1 = A<long long, 1>();
A<unsigned int, 1> a2 = A<int, 5>();
A<bool, true> a3 = A<signed char, true>();
}
// CHECK-ELIDE-NOTREE: error: no viable conversion from 'A<long long, (long long) 1>' to 'A<int, (int) 1>'
// CHECK-ELIDE-NOTREE: error: no viable conversion from 'A<int, (int) 5>' to 'A<unsigned int, (unsigned int) 1>'
// CHECK-ELIDE-NOTREE: error: no viable conversion from 'A<signed char, (signed char) 1>' to 'A<bool, (bool) true>'
}
Add new diff modes to template type diffing. Remove an old assertion that does not hold. It is possible for a template argument to be a declaration in one instantiation and an integer in another. Create two new diff kinds for these (decl vs int and int vs decl). llvm-svn: 257869
2016-01-15 13:01:53 +08:00
namespace MixedDeclarationIntegerArgument {
template<typename T, T n> class A{};
int x;
int y[5];
A<int, 5> a1 = A<int&, x>();
A<int, 5 - 1> a2 = A<int*, &x>();
A<int, 5 + 1> a3 = A<int*, y>();
A<int, 0> a4 = A<int**, nullptr>();
// CHECK-ELIDE-NOTREE: error: no viable conversion from 'A<int &, x>' to 'A<int, 5>'
// CHECK-ELIDE-NOTREE: error: no viable conversion from 'A<int *, &x>' to 'A<int, 5 - 1 aka 4>'
// CHECK-ELIDE-NOTREE: error: no viable conversion from 'A<int *, y>' to 'A<int, 5 + 1 aka 6>'
// CHECK-ELIDE-NOTREE: error: no viable conversion from 'A<int **, nullptr>' to 'A<int, 0>'
// CHECK-ELIDE-TREE: error: no viable conversion
// CHECK-ELIDE-TREE: A<
// CHECK-ELIDE-TREE: [int & != int],
// CHECK-ELIDE-TREE: [x != 5]>
// CHECK-ELIDE-TREE: error: no viable conversion
// CHECK-ELIDE-TREE: A<
// CHECK-ELIDE-TREE: [int * != int],
// CHECK-ELIDE-TREE: [&x != 5 - 1 aka 4]>
// CHECK-ELIDE-TREE: error: no viable conversion
// CHECK-ELIDE-TREE: A<
// CHECK-ELIDE-TREE: [int * != int],
// CHECK-ELIDE-TREE: [y != 5 + 1 aka 6]>
// CHECK-ELIDE-TREE: error: no viable conversion
// CHECK-ELIDE-TREE: A<
// CHECK-ELIDE-TREE: [int ** != int],
// CHECK-ELIDE-TREE: [nullptr != 0]>
A<int&, x> a5 = A<int, 3>();
A<int*, &x> a6 = A<int, 3 - 1>();
A<int*, y> a7 = A<int, 3 + 1>();
A<int**, nullptr> a8 = A<int, 3>();
// CHECK-ELIDE-NOTREE: error: no viable conversion from 'A<int, 3>' to 'A<int &, x>'
// CHECK-ELIDE-NOTREE: error: no viable conversion from 'A<int, 3 - 1 aka 2>' to 'A<int *, &x>'
// CHECK-ELIDE-NOTREE: error: no viable conversion from 'A<int, 3 + 1 aka 4>' to 'A<int *, y>'
// CHECK-ELIDE-NOTREE: error: no viable conversion from 'A<int, 3>' to 'A<int **, nullptr>'
// CHECK-ELIDE-TREE: error: no viable conversion
// CHECK-ELIDE-TREE: A<
// CHECK-ELIDE-TREE: [int != int &],
// CHECK-ELIDE-TREE: [3 != x]>
// CHECK-ELIDE-TREE: error: no viable conversion
// CHECK-ELIDE-TREE: A<
// CHECK-ELIDE-TREE: [int != int *],
// CHECK-ELIDE-TREE: [3 - 1 aka 2 != &x]>
// CHECK-ELIDE-TREE: error: no viable conversion
// CHECK-ELIDE-TREE: A<
// CHECK-ELIDE-TREE: [int != int *],
// CHECK-ELIDE-TREE: [3 + 1 aka 4 != y]>
// CHECK-ELIDE-TREE: error: no viable conversion
// CHECK-ELIDE-TREE: A<
// CHECK-ELIDE-TREE: [int != int **],
// CHECK-ELIDE-TREE: [3 != nullptr]>
template<class T, T n = x> class B{} ;
B<int, 5> b1 = B<int&>();
// CHECK-ELIDE-NOTREE: error: no viable conversion from 'B<int &, (default) x>' to 'B<int, 5>'
// CHECK-ELIDE-TREE: error: no viable conversion
// CHECK-ELIDE-TREE: B<
// CHECK-ELIDE-TREE: [int & != int],
// CHECK-ELIDE-TREE: [(default) x != 5]>
B<int &> b2 = B<int, 2>();
// CHECK-ELIDE-NOTREE: error: no viable conversion from 'B<int, 2>' to 'B<int &, (default) x>'
// CHECK-ELIDE-TREE: B<
// CHECK-ELIDE-TREE: [int != int &],
// CHECK-ELIDE-TREE: [2 != (default) x]>
template<class T, T n = 11> class C {};
C<int> c1 = C<int&, x>();
// CHECK-ELIDE-NOTREE: error: no viable conversion from 'C<int &, x>' to 'C<int, (default) 11>'
// CHECK-ELIDE-TREE: error: no viable conversion
// CHECK-ELIDE-TREE: C<
// CHECK-ELIDE-TREE: [int & != int],
// CHECK-ELIDE-TREE: [x != (default) 11]>
C<int &, x> c2 = C<int>();
// CHECK-ELIDE-NOTREE: error: no viable conversion from 'C<int, (default) 11>' to 'C<int &, x>'
// CHECK-ELIDE-TREE: C<
// CHECK-ELIDE-TREE: [int != int &],
// CHECK-ELIDE-TREE: [(default) 11 != x]>
}
Save the integer type for integral template arguments. Save the integer type when diffing integers in template type diffing. When integers are different sizes, print out the type along with the integer value. Also with the type information, print true and false instead of 1 and 0 for boolean values. llvm-svn: 257861
2016-01-15 10:55:17 +08:00
Fixing more issues with template type diffing 1) Print qualifiers for templates with zero arguments 2) Add a few more tests for the template type diffing refactoring. Specifically, PR24587 has been fixed and has a test case from http://reviews.llvm.org/D15384 3) Adds asserts to check the DiffTree is in correct state when moving nodes 4) Rename the field FromType and ToType since it is heavily used within member functions. llvm-svn: 257870
2016-01-15 13:48:38 +08:00
namespace default_args {
template <int x, int y = 1+1, int z = 2>
class A {};
void foo(A<0> &M) {
// CHECK-ELIDE-NOTREE: no viable conversion from 'A<[...], (default) 1 + 1 aka 2, (default) 2>' to 'A<[...], 0, 0>'
A<0, 0, 0> N = M;
// CHECK-ELIDE-NOTREE: no viable conversion from 'A<[2 * ...], (default) 2>' to 'A<[2 * ...], 0>'
A<0, 2, 0> N2 = M;
}
}
namespace DefaultNonTypeArgWithDependentType {
// We used to crash diffing integer template arguments when the argument type
// is dependent and default arguments were used.
template <typename SizeType = int, SizeType = 0> struct A {};
template <typename R = A<>> R bar();
A<> &foo() { return bar(); }
Template Type Diffing change When all the arguments of a template are elided, print "A<...>" instead of "A<[2 * ...]>". Also remove comment fragment that means nothing. llvm-svn: 259445
2016-02-02 08:36:59 +08:00
// CHECK-ELIDE-NOTREE: error: non-const lvalue reference to type 'A<...>' cannot bind to a temporary of type 'A<...>'
Fixing more issues with template type diffing 1) Print qualifiers for templates with zero arguments 2) Add a few more tests for the template type diffing refactoring. Specifically, PR24587 has been fixed and has a test case from http://reviews.llvm.org/D15384 3) Adds asserts to check the DiffTree is in correct state when moving nodes 4) Rename the field FromType and ToType since it is heavily used within member functions. llvm-svn: 257870
2016-01-15 13:48:38 +08:00
// CHECK-NOELIDE-NOTREE: error: non-const lvalue reference to type 'A<int, 0>' cannot bind to a temporary of type 'A<int, 0>'
}
namespace PR24587 {
template <typename T, T v>
struct integral_constant {};
auto false_ = integral_constant<bool, false> {};
template <typename T>
void f(T, decltype(false_));
void run() {
f(1, integral_constant<bool, true>{});
}
// CHECK-ELIDE-NOTREE: error: no matching function for call to 'f'
Fix test failure after r333485. Try 2. Sorry for the breakage. llvm-svn: 333491
2018-05-30 10:20:40 +08:00
// CHECK-ELIDE-NOTREE: note: candidate function template not viable: no known conversion from 'integral_constant<[...], true>' to 'integral_constant<[...], false>' for 2nd argument
Fixing more issues with template type diffing 1) Print qualifiers for templates with zero arguments 2) Add a few more tests for the template type diffing refactoring. Specifically, PR24587 has been fixed and has a test case from http://reviews.llvm.org/D15384 3) Adds asserts to check the DiffTree is in correct state when moving nodes 4) Rename the field FromType and ToType since it is heavily used within member functions. llvm-svn: 257870
2016-01-15 13:48:38 +08:00
}
namespace ZeroArgs {
template <int N = 0> class A {};
template <class T = A<>> class B {};
A<1> a1 = A<>();
A<> a2 = A<1>();
B<> b1 = B<int>();
B<int> b2 = B<>();
B<> b3 = B<const A<>>();
B<const A<>> b4 = B<>();
// CHECK-ELIDE-NOTREE: error: no viable conversion from 'A<(default) 0>' to 'A<1>'
// CHECK-ELIDE-NOTREE: error: no viable conversion from 'A<1>' to 'A<(default) 0>'
// CHECK-ELIDE-NOTREE: error: no viable conversion from 'B<int>' to 'B<(default) ZeroArgs::A<0>>'
// CHECK-ELIDE-NOTREE: error: no viable conversion from 'B<(default) ZeroArgs::A<0>>' to 'B<int>'
Template Type Diffing change When all the arguments of a template are elided, print "A<...>" instead of "A<[2 * ...]>". Also remove comment fragment that means nothing. llvm-svn: 259445
2016-02-02 08:36:59 +08:00
// CHECK-ELIDE-NOTREE: error: no viable conversion from 'B<const A<...>>' to 'B<A<...>>'
// CHECK-ELIDE-NOTREE: error: no viable conversion from 'B<A<...>>' to 'B<const A<...>>'
Fixing more issues with template type diffing 1) Print qualifiers for templates with zero arguments 2) Add a few more tests for the template type diffing refactoring. Specifically, PR24587 has been fixed and has a test case from http://reviews.llvm.org/D15384 3) Adds asserts to check the DiffTree is in correct state when moving nodes 4) Rename the field FromType and ToType since it is heavily used within member functions. llvm-svn: 257870
2016-01-15 13:48:38 +08:00
}
Fix Clang crash with template type diffing. Fixes https://llvm.org/bugs/show_bug.cgi?id=27129 which is crash involving type aliases and template type diffing. Template arguments for type aliases and template arguments for the underlying desugared type may not have one-to-one relations, which could mess us the attempt to get more information from the desugared type. For type aliases, ignore the iterator over the desugared type. llvm-svn: 264940
2016-03-31 06:23:00 +08:00
namespace TypeAlias {
template <typename T> class vector {};
template <int Dimension> class Point;
template <int dimension, typename T> using Polygon = vector<Point<dimension>>;
void foo(Polygon<3, float>);
void bar() { foo(Polygon<2, float>()); }
// CHECK-ELIDE-NOTREE: error: no matching function for call to 'foo'
// CHECK-ELIDE-NOTREE: note: candidate function not viable: no known conversion from 'Polygon<2, [...]>' to 'Polygon<3, [...]>' for 1st argument
enum class X {
X1,
X2,
};
template<X x> struct EnumToType;
template <> struct EnumToType<X::X1> { using type = int; };
template <> struct EnumToType<X::X2> { using type = double; };
template <X x> using VectorType = vector<typename EnumToType<x>::type>;
template <X x> void D(const VectorType<x>&);
void run() {
D<X::X1>(VectorType<X::X2>());
}
// CHECK-ELIDE-NOTREE: error: no matching function for call to 'D'
Fix test failure after r333485. Try 2. Sorry for the breakage. llvm-svn: 333491
2018-05-30 10:20:40 +08:00
// CHECK-ELIDE-NOTREE: note: candidate function template not viable: no known conversion from 'VectorType<X::X2>' to 'const VectorType<(TypeAlias::X)0>' for 1st argument
Fix crash in template type diffing. When the type being diffed is a type alias, and the orginal type is not a templated type, then there will be no unsugared TemplateSpecializationType. When this happens, exit early from the constructor. Also add assertions to the other iterator accessor to prevent the iterator from being used. llvm-svn: 277797
2016-08-05 11:16:36 +08:00
}
namespace TypeAlias2 {
template <typename T>
class A {};
template <typename T>
using A_reg = A<T>;
void take_reg(A_reg<int>);
template <typename T>
using A_ptr = A<T> *;
void take_ptr(A_ptr<int>);
template <typename T>
using A_ref = const A<T> &;
void take_ref(A_ref<int>);
Fix Clang crash with template type diffing. Fixes https://llvm.org/bugs/show_bug.cgi?id=27129 which is crash involving type aliases and template type diffing. Template arguments for type aliases and template arguments for the underlying desugared type may not have one-to-one relations, which could mess us the attempt to get more information from the desugared type. For type aliases, ignore the iterator over the desugared type. llvm-svn: 264940
2016-03-31 06:23:00 +08:00
Fix crash in template type diffing. When the type being diffed is a type alias, and the orginal type is not a templated type, then there will be no unsugared TemplateSpecializationType. When this happens, exit early from the constructor. Also add assertions to the other iterator accessor to prevent the iterator from being used. llvm-svn: 277797
2016-08-05 11:16:36 +08:00
void run(A_reg<float> reg, A_ptr<float> ptr, A_ref<float> ref) {
take_reg(reg);
// CHECK-ELIDE-NOTREE: error: no matching function for call to 'take_reg'
// CHECK-ELIDE-NOTREE: note: candidate function not viable: no known conversion from 'A_reg<float>' to 'A_reg<int>' for 1st argument
take_ptr(ptr);
// CHECK-ELIDE-NOTREE: error: no matching function for call to 'take_ptr'
// CHECK-ELIDE-NOTREE: note: candidate function not viable: no known conversion from 'A_ptr<float>' to 'A_ptr<int>' for 1st argument
take_ref(ref);
// CHECK-ELIDE-NOTREE: error: no matching function for call to 'take_ref'
// CHECK-ELIDE-NOTREE: note: candidate function not viable: no known conversion from 'const A<float>' to 'const A<int>' for 1st argument
}
Fix Clang crash with template type diffing. Fixes https://llvm.org/bugs/show_bug.cgi?id=27129 which is crash involving type aliases and template type diffing. Template arguments for type aliases and template arguments for the underlying desugared type may not have one-to-one relations, which could mess us the attempt to get more information from the desugared type. For type aliases, ignore the iterator over the desugared type. llvm-svn: 264940
2016-03-31 06:23:00 +08:00
}
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. llvm-svn: 159216
2012-06-27 02:18:47 +08:00
// 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.
PR30831: Teach template type diffing to cope with TemplateSpecializationTypes that desugar to non-TSTs (such as injected-class-names). llvm-svn: 285437
2016-10-29 03:54:43 +08:00
namespace pr30831 {
template <typename T> struct A { static A<T> const a; };
template <typename T> A<T> A<T>::a = A<T>();
}