1500 lines
73 KiB
C++
1500 lines
73 KiB
C++
// 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
|
|
|
|
// PR9548 - "no known conversion from 'vector<string>' to 'vector<string>'"
|
|
// vector<string> refers to two different types here. Make sure the message
|
|
// gives a way to tell them apart.
|
|
class versa_string;
|
|
typedef versa_string string;
|
|
|
|
namespace std {template <typename T> class vector;}
|
|
using std::vector;
|
|
|
|
void f(vector<string> v);
|
|
|
|
namespace std {
|
|
class basic_string;
|
|
typedef basic_string string;
|
|
template <typename T> class vector {};
|
|
void g() {
|
|
vector<string> v;
|
|
f(v);
|
|
}
|
|
} // end namespace std
|
|
// CHECK-ELIDE-NOTREE: no matching function for call to 'f'
|
|
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<std::string>' to 'vector<string>' for 1st argument
|
|
// CHECK-NOELIDE-NOTREE: no matching function for call to 'f'
|
|
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<std::string>' to 'vector<string>' for 1st argument
|
|
// CHECK-ELIDE-TREE: no matching function for call to 'f'
|
|
// 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: [std::string != string]>
|
|
// CHECK-NOELIDE-TREE: no matching function for call to 'f'
|
|
// 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: [std::string != string]>
|
|
|
|
template <int... A>
|
|
class I1{};
|
|
void set1(I1<1,2,3,4,2,3,4,3>) {};
|
|
void test1() {
|
|
set1(I1<1,2,3,4,2,2,4,3,7>());
|
|
}
|
|
// CHECK-ELIDE-NOTREE: no matching function for call to 'set1'
|
|
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'I1<[5 * ...], 2, [2 * ...], 7>' to 'I1<[5 * ...], 3, [2 * ...], (no argument)>' for 1st argument
|
|
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set1'
|
|
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'I1<1, 2, 3, 4, 2, 2, 4, 3, 7>' to 'I1<1, 2, 3, 4, 2, 3, 4, 3, (no argument)>' for 1st argument
|
|
// CHECK-ELIDE-TREE: no matching function for call to 'set1'
|
|
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-ELIDE-TREE: I1<
|
|
// CHECK-ELIDE-TREE: [5 * ...],
|
|
// CHECK-ELIDE-TREE: [2 != 3],
|
|
// CHECK-ELIDE-TREE: [2 * ...],
|
|
// CHECK-ELIDE-TREE: [7 != (no argument)]>
|
|
// CHECK-NOELIDE-TREE: no matching function for call to 'set1'
|
|
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-NOELIDE-TREE: I1<
|
|
// CHECK-NOELIDE-TREE: 1,
|
|
// CHECK-NOELIDE-TREE: 2,
|
|
// CHECK-NOELIDE-TREE: 3,
|
|
// CHECK-NOELIDE-TREE: 4,
|
|
// CHECK-NOELIDE-TREE: 2,
|
|
// CHECK-NOELIDE-TREE: [2 != 3],
|
|
// CHECK-NOELIDE-TREE: 4,
|
|
// CHECK-NOELIDE-TREE: 3,
|
|
// CHECK-NOELIDE-TREE: [7 != (no argument)]>
|
|
|
|
template <class A, class B, class C = void>
|
|
class I2{};
|
|
void set2(I2<int, int>) {};
|
|
void test2() {
|
|
set2(I2<double, int, int>());
|
|
}
|
|
// CHECK-ELIDE-NOTREE: no matching function for call to 'set2'
|
|
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'I2<double, [...], int>' to 'I2<int, [...], (default) void>' for 1st argument
|
|
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set2'
|
|
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'I2<double, int, int>' to 'I2<int, int, (default) void>' for 1st argument
|
|
// CHECK-ELIDE-TREE: no matching function for call to 'set2'
|
|
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-ELIDE-TREE: I2<
|
|
// CHECK-ELIDE-TREE: [double != int],
|
|
// CHECK-ELIDE-TREE: [...],
|
|
// CHECK-ELIDE-TREE: [int != (default) void]>
|
|
// CHECK-NOELIDE-TREE: no matching function for call to 'set2'
|
|
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-NOELIDE-TREE: I2<
|
|
// CHECK-NOELIDE-TREE: [double != int],
|
|
// CHECK-NOELIDE-TREE: int,
|
|
// CHECK-NOELIDE-TREE: [int != (default) void]>
|
|
|
|
int V1, V2, V3;
|
|
template <int* A, int *B>
|
|
class I3{};
|
|
void set3(I3<&V1, &V2>) {};
|
|
void test3() {
|
|
set3(I3<&V3, &V2>());
|
|
}
|
|
// CHECK-ELIDE-NOTREE: no matching function for call to 'set3'
|
|
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'I3<&V3, [...]>' to 'I3<&V1, [...]>' for 1st argument
|
|
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set3'
|
|
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'I3<&V3, &V2>' to 'I3<&V1, &V2>' for 1st argument
|
|
// CHECK-ELIDE-TREE: no matching function for call to 'set3'
|
|
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-ELIDE-TREE: I3<
|
|
// CHECK-ELIDE-TREE: [&V3 != &V1]
|
|
// CHECK-ELIDE-TREE: [...]>
|
|
// CHECK-NOELIDE-TREE: no matching function for call to 'set3'
|
|
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-NOELIDE-TREE: I3<
|
|
// CHECK-NOELIDE-TREE: [&V3 != &V1]
|
|
// CHECK-NOELIDE-TREE: &V2>
|
|
|
|
template <class A, class B>
|
|
class Alpha{};
|
|
template <class A, class B>
|
|
class Beta{};
|
|
template <class A, class B>
|
|
class Gamma{};
|
|
template <class A, class B>
|
|
class Delta{};
|
|
|
|
void set4(Alpha<int, int>);
|
|
void test4() {
|
|
set4(Beta<void, void>());
|
|
}
|
|
// CHECK-ELIDE-NOTREE: no matching function for call to 'set4'
|
|
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'Beta<void, void>' to 'Alpha<int, int>' for 1st argument
|
|
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set4'
|
|
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'Beta<void, void>' to 'Alpha<int, int>' for 1st argument
|
|
// CHECK-ELIDE-TREE: no matching function for call to 'set4'
|
|
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from 'Beta<void, void>' to 'Alpha<int, int>' for 1st argument
|
|
// CHECK-NOELIDE-TREE: no matching function for call to 'set4'
|
|
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from 'Beta<void, void>' to 'Alpha<int, int>' for 1st argument
|
|
|
|
void set5(Alpha<Beta<Gamma<Delta<int, int>, int>, int>, int>);
|
|
void test5() {
|
|
set5(Alpha<Beta<Gamma<void, void>, double>, double>());
|
|
}
|
|
// CHECK-ELIDE-NOTREE: no matching function for call to 'set5'
|
|
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'Alpha<Beta<Gamma<void, void>, double>, double>' to 'Alpha<Beta<Gamma<Delta<int, int>, int>, int>, int>' for 1st argument
|
|
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set5'
|
|
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'Alpha<Beta<Gamma<void, void>, double>, double>' to 'Alpha<Beta<Gamma<Delta<int, int>, int>, int>, int>' for 1st argument
|
|
// CHECK-ELIDE-TREE: no matching function for call to 'set5'
|
|
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-ELIDE-TREE: Alpha<
|
|
// CHECK-ELIDE-TREE: Beta<
|
|
// CHECK-ELIDE-TREE: Gamma<
|
|
// CHECK-ELIDE-TREE: [void != Delta<int, int>],
|
|
// CHECK-ELIDE-TREE: [void != int]>
|
|
// CHECK-ELIDE-TREE: [double != int]>
|
|
// CHECK-ELIDE-TREE: [double != int]>
|
|
// CHECK-NOELIDE-TREE: no matching function for call to 'set5'
|
|
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-NOELIDE-TREE: Alpha<
|
|
// CHECK-NOELIDE-TREE: Beta<
|
|
// CHECK-NOELIDE-TREE: Gamma<
|
|
// CHECK-NOELIDE-TREE: [void != Delta<int, int>],
|
|
// CHECK-NOELIDE-TREE: [void != int]>
|
|
// CHECK-NOELIDE-TREE: [double != int]>
|
|
// CHECK-NOELIDE-TREE: [double != int]>
|
|
|
|
void test6() {
|
|
set5(Alpha<Beta<Delta<int, int>, int>, int>());
|
|
}
|
|
// CHECK-ELIDE-NOTREE: no matching function for call to 'set5'
|
|
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'Alpha<Beta<Delta<int, int>, [...]>, [...]>' to 'Alpha<Beta<Gamma<Delta<int, int>, int>, [...]>, [...]>' for 1st argument
|
|
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set5'
|
|
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'Alpha<Beta<Delta<int, int>, int>, int>' to 'Alpha<Beta<Gamma<Delta<int, int>, int>, int>, int>' for 1st argument
|
|
// CHECK-ELIDE-TREE: no matching function for call to 'set5'
|
|
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-ELIDE-TREE: Alpha<
|
|
// CHECK-ELIDE-TREE: Beta<
|
|
// CHECK-ELIDE-TREE: [Delta<int, int> != Gamma<Delta<int, int>, int>],
|
|
// CHECK-ELIDE-TREE: [...]>
|
|
// CHECK-ELIDE-TREE: [...]>
|
|
// CHECK-NOELIDE-TREE: no matching function for call to 'set5'
|
|
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-NOELIDE-TREE: Alpha<
|
|
// CHECK-NOELIDE-TREE: Beta<
|
|
// CHECK-NOELIDE-TREE: [Delta<int, int> != Gamma<Delta<int, int>, int>],
|
|
// CHECK-NOELIDE-TREE: int>
|
|
// CHECK-NOELIDE-TREE: int>
|
|
|
|
int a7, b7;
|
|
int c7[] = {1,2,3};
|
|
template<int *A>
|
|
class class7 {};
|
|
void set7(class7<&a7> A) {}
|
|
void test7() {
|
|
set7(class7<&a7>());
|
|
set7(class7<&b7>());
|
|
set7(class7<c7>());
|
|
set7(class7<nullptr>());
|
|
}
|
|
// CHECK-ELIDE-NOTREE: no matching function for call to 'set7'
|
|
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'class7<&b7>' to 'class7<&a7>' for 1st argument
|
|
// CHECK-ELIDE-NOTREE: no matching function for call to 'set7'
|
|
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'class7<c7>' to 'class7<&a7>' for 1st argument
|
|
// CHECK-ELIDE-NOTREE: no matching function for call to 'set7'
|
|
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'class7<nullptr>' to 'class7<&a7>' for 1st argument
|
|
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set7'
|
|
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'class7<&b7>' to 'class7<&a7>' for 1st argument
|
|
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set7'
|
|
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'class7<c7>' to 'class7<&a7>' for 1st argument
|
|
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set7'
|
|
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'class7<nullptr>' to 'class7<&a7>' for 1st argument
|
|
// CHECK-ELIDE-TREE: no matching function for call to 'set7'
|
|
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-ELIDE-TREE: class7<
|
|
// CHECK-ELIDE-TREE: [&b7 != &a7]>
|
|
// CHECK-ELIDE-TREE: no matching function for call to 'set7'
|
|
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-ELIDE-TREE: class7<
|
|
// CHECK-ELIDE-TREE: [c7 != &a7]>
|
|
// CHECK-ELIDE-TREE: no matching function for call to 'set7'
|
|
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-ELIDE-TREE: class7<
|
|
// CHECK-ELIDE-TREE: [nullptr != &a7]>
|
|
// CHECK-NOELIDE-TREE: no matching function for call to 'set7'
|
|
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-NOELIDE-TREE: class7<
|
|
// CHECK-NOELIDE-TREE: [&b7 != &a7]>
|
|
// CHECK-NOELIDE-TREE: no matching function for call to 'set7'
|
|
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-NOELIDE-TREE: class7<
|
|
// CHECK-NOELIDE-TREE: [c7 != &a7]>
|
|
// CHECK-NOELIDE-TREE: no matching function for call to 'set7'
|
|
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-NOELIDE-TREE: class7<
|
|
// CHECK-NOELIDE-TREE: [nullptr != &a7]>
|
|
|
|
template<typename ...T> struct S8 {};
|
|
template<typename T> using U8 = S8<int, char, T>;
|
|
int f8(S8<int, char, double>);
|
|
int k8 = f8(U8<char>());
|
|
// CHECK-ELIDE-NOTREE: no matching function for call to 'f8'
|
|
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'S8<[2 * ...], char>' to 'S8<[2 * ...], double>' for 1st argument
|
|
// CHECK-NOELIDE-NOTREE: no matching function for call to 'f8'
|
|
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'S8<int, char, char>' to 'S8<int, char, double>' for 1st argument
|
|
// CHECK-ELIDE-TREE: no matching function for call to 'f8'
|
|
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-ELIDE-TREE: S8<
|
|
// CHECK-ELIDE-TREE: [2 * ...],
|
|
// CHECK-ELIDE-TREE: [char != double]>
|
|
// CHECK-NOELIDE-TREE: no matching function for call to 'f8'
|
|
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-NOELIDE-TREE: S8<
|
|
// CHECK-NOELIDE-TREE: int,
|
|
// CHECK-NOELIDE-TREE: char,
|
|
// CHECK-NOELIDE-TREE: [char != double]>
|
|
|
|
template<typename ...T> struct S9 {};
|
|
template<typename T> using U9 = S9<int, char, T>;
|
|
template<typename T> using V9 = U9<U9<T>>;
|
|
int f9(S9<int, char, U9<const double>>);
|
|
int k9 = f9(V9<double>());
|
|
|
|
// CHECK-ELIDE-NOTREE: no matching function for call to 'f9'
|
|
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'S9<[2 * ...], S9<[2 * ...], double>>' to 'S9<[2 * ...], S9<[2 * ...], const double>>' for 1st argument
|
|
// CHECK-NOELIDE-NOTREE: no matching function for call to 'f9'
|
|
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'S9<int, char, S9<int, char, double>>' to 'S9<int, char, S9<int, char, const double>>' for 1st argument
|
|
// CHECK-ELIDE-TREE: no matching function for call to 'f9'
|
|
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-ELIDE-TREE: S9<
|
|
// CHECK-ELIDE-TREE: [2 * ...],
|
|
// CHECK-ELIDE-TREE: S9<
|
|
// CHECK-ELIDE-TREE: [2 * ...],
|
|
// CHECK-ELIDE-TREE: [double != const double]>>
|
|
// CHECK-NOELIDE-TREE: no matching function for call to 'f9'
|
|
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-NOELIDE-TREE: S9<
|
|
// CHECK-NOELIDE-TREE: int,
|
|
// CHECK-NOELIDE-TREE: char,
|
|
// CHECK-NOELIDE-TREE: S9<
|
|
// CHECK-NOELIDE-TREE: int,
|
|
// CHECK-NOELIDE-TREE: char,
|
|
// CHECK-NOELIDE-TREE: [double != const double]>>
|
|
|
|
template<typename ...A> class class_types {};
|
|
void set10(class_types<int, int>) {}
|
|
void test10() {
|
|
set10(class_types<int>());
|
|
set10(class_types<int, int, int>());
|
|
}
|
|
|
|
// CHECK-ELIDE-NOTREE: no matching function for call to 'set10'
|
|
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'class_types<[...], (no argument)>' to 'class_types<[...], int>' for 1st argument
|
|
// CHECK-ELIDE-NOTREE: no matching function for call to 'set10'
|
|
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'class_types<[2 * ...], int>' to 'class_types<[2 * ...], (no argument)>' for 1st argument
|
|
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set10'
|
|
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'class_types<int, (no argument)>' to 'class_types<int, int>' for 1st argument
|
|
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set10'
|
|
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'class_types<int, int, int>' to 'class_types<int, int, (no argument)>' for 1st argument
|
|
// CHECK-ELIDE-TREE: no matching function for call to 'set10'
|
|
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-ELIDE-TREE: class_types<
|
|
// CHECK-ELIDE-TREE: [...],
|
|
// CHECK-ELIDE-TREE: [(no argument) != int]>
|
|
// CHECK-ELIDE-TREE: no matching function for call to 'set10'
|
|
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-ELIDE-TREE: class_types<
|
|
// CHECK-ELIDE-TREE: [2 * ...],
|
|
// CHECK-ELIDE-TREE: [int != (no argument)]>
|
|
// CHECK-NOELIDE-TREE: no matching function for call to 'set10'
|
|
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-NOELIDE-TREE: class_types<
|
|
// CHECK-NOELIDE-TREE: int,
|
|
// CHECK-NOELIDE-TREE: [(no argument) != int]>
|
|
// CHECK-NOELIDE-TREE: no matching function for call to 'set10'
|
|
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-NOELIDE-TREE: class_types<
|
|
// CHECK-NOELIDE-TREE: int,
|
|
// CHECK-NOELIDE-TREE: int,
|
|
// CHECK-NOELIDE-TREE: [int != (no argument)]>
|
|
|
|
template<int ...A> class class_ints {};
|
|
void set11(class_ints<2, 3>) {}
|
|
void test11() {
|
|
set11(class_ints<1>());
|
|
set11(class_ints<0, 3, 6>());
|
|
}
|
|
// CHECK-ELIDE-NOTREE: no matching function for call to 'set11'
|
|
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'class_ints<1, (no argument)>' to 'class_ints<2, 3>' for 1st argument
|
|
// CHECK-ELIDE-NOTREE: no matching function for call to 'set11'
|
|
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'class_ints<0, [...], 6>' to 'class_ints<2, [...], (no argument)>' for 1st argument
|
|
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set11'
|
|
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'class_ints<1, (no argument)>' to 'class_ints<2, 3>' for 1st argument
|
|
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set11'
|
|
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'class_ints<0, 3, 6>' to 'class_ints<2, 3, (no argument)>' for 1st argument
|
|
// CHECK-ELIDE-TREE: no matching function for call to 'set11'
|
|
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-ELIDE-TREE: class_ints<
|
|
// CHECK-ELIDE-TREE: [1 != 2],
|
|
// CHECK-ELIDE-TREE: [(no argument) != 3]>
|
|
// CHECK-ELIDE-TREE: no matching function for call to 'set11'
|
|
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-ELIDE-TREE: class_ints<
|
|
// CHECK-ELIDE-TREE: [0 != 2],
|
|
// CHECK-ELIDE-TREE: [...],
|
|
// CHECK-ELIDE-TREE: [6 != (no argument)]>
|
|
// CHECK-NOELIDE-TREE: no matching function for call to 'set11'
|
|
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-NOELIDE-TREE: class_ints<
|
|
// CHECK-NOELIDE-TREE: [1 != 2],
|
|
// CHECK-NOELIDE-TREE: [(no argument) != 3]>
|
|
// CHECK-NOELIDE-TREE: no matching function for call to 'set11'
|
|
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-NOELIDE-TREE: class_ints<
|
|
// CHECK-NOELIDE-TREE: [0 != 2],
|
|
// CHECK-NOELIDE-TREE: 3,
|
|
// CHECK-NOELIDE-TREE: [6 != (no argument)]>
|
|
|
|
template<template<class> class ...A> class class_template_templates {};
|
|
template<class> class tt1 {};
|
|
template<class> class tt2 {};
|
|
void set12(class_template_templates<tt1, tt1>) {}
|
|
void test12() {
|
|
set12(class_template_templates<tt2>());
|
|
set12(class_template_templates<tt1, tt1, tt1>());
|
|
}
|
|
// CHECK-ELIDE-NOTREE: no matching function for call to 'set12'
|
|
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'class_template_templates<template tt2, template (no argument)>' to 'class_template_templates<template tt1, template tt1>' for 1st argument
|
|
// CHECK-ELIDE-NOTREE: no matching function for call to 'set12'
|
|
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'class_template_templates<[2 * ...], template tt1>' to 'class_template_templates<[2 * ...], template (no argument)>' for 1st argument
|
|
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set12'
|
|
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'class_template_templates<template tt2, template (no argument)>' to 'class_template_templates<template tt1, template tt1>' for 1st argument
|
|
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set12'
|
|
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'class_template_templates<template tt1, template tt1, template tt1>' to 'class_template_templates<template tt1, template tt1, template (no argument)>' for 1st argument
|
|
// CHECK-ELIDE-TREE: no matching function for call to 'set12'
|
|
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-ELIDE-TREE: class_template_templates<
|
|
// CHECK-ELIDE-TREE: [template tt2 != template tt1],
|
|
// CHECK-ELIDE-TREE: [template (no argument) != template tt1]>
|
|
// CHECK-ELIDE-TREE: no matching function for call to 'set12'
|
|
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-ELIDE-TREE: class_template_templates<
|
|
// CHECK-ELIDE-TREE: [2 * ...],
|
|
// CHECK-ELIDE-TREE: [template tt1 != template (no argument)]>
|
|
// CHECK-NOELIDE-TREE: no matching function for call to 'set12'
|
|
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-NOELIDE-TREE: class_template_templates<
|
|
// CHECK-NOELIDE-TREE: [template tt2 != template tt1],
|
|
// CHECK-NOELIDE-TREE: [template (no argument) != template tt1]>
|
|
// CHECK-NOELIDE-TREE: no matching function for call to 'set12'
|
|
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-NOELIDE-TREE: class_template_templates<
|
|
// CHECK-NOELIDE-TREE: template tt1,
|
|
// CHECK-NOELIDE-TREE: template tt1,
|
|
// CHECK-NOELIDE-TREE: [template tt1 != template (no argument)]>
|
|
|
|
double a13, b13, c13, d13;
|
|
template<double* ...A> class class_ptrs {};
|
|
void set13(class_ptrs<&a13, &b13>) {}
|
|
void test13() {
|
|
set13(class_ptrs<&c13>());
|
|
set13(class_ptrs<&a13, &b13, &d13>());
|
|
}
|
|
// CHECK-ELIDE-NOTREE: no matching function for call to 'set13'
|
|
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'class_ptrs<&c13, (no argument)>' to 'class_ptrs<&a13, &b13>' for 1st argument
|
|
// CHECK-ELIDE-NOTREE: no matching function for call to 'set13'
|
|
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'class_ptrs<[2 * ...], &d13>' to 'class_ptrs<[2 * ...], (no argument)>' for 1st argument
|
|
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set13'
|
|
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'class_ptrs<&c13, (no argument)>' to 'class_ptrs<&a13, &b13>' for 1st argument
|
|
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set13'
|
|
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'class_ptrs<&a13, &b13, &d13>' to 'class_ptrs<&a13, &b13, (no argument)>' for 1st argument
|
|
// CHECK-ELIDE-TREE: no matching function for call to 'set13'
|
|
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-ELIDE-TREE: class_ptrs<
|
|
// CHECK-ELIDE-TREE: [&c13 != &a13],
|
|
// CHECK-ELIDE-TREE: [(no argument) != &b13]>
|
|
// CHECK-ELIDE-TREE: no matching function for call to 'set13'
|
|
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-ELIDE-TREE: class_ptrs<
|
|
// CHECK-ELIDE-TREE: [2 * ...],
|
|
// CHECK-ELIDE-TREE: [&d13 != (no argument)]>
|
|
// CHECK-NOELIDE-TREE: no matching function for call to 'set13'
|
|
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-NOELIDE-TREE: class_ptrs<
|
|
// CHECK-NOELIDE-TREE: [&c13 != &a13],
|
|
// CHECK-NOELIDE-TREE: [(no argument) != &b13]>
|
|
// CHECK-NOELIDE-TREE: no matching function for call to 'set13'
|
|
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-NOELIDE-TREE: class_ptrs<
|
|
// CHECK-NOELIDE-TREE: &a13,
|
|
// CHECK-NOELIDE-TREE: &b13,
|
|
// CHECK-NOELIDE-TREE: [&d13 != (no argument)]>
|
|
|
|
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]>
|
|
|
|
void set15(vector<vector<int>>) {}
|
|
void test15() {
|
|
set15(vector<vector<int>>());
|
|
}
|
|
// CHECK-ELIDE-NOTREE-NOT: set15
|
|
// CHECK-NOELIDE-NOTREE-NOT: set15
|
|
// CHECK-ELIDE-TREE-NOT: set15
|
|
// CHECK-NOELIDE-TREE-NOT: set15
|
|
// no error here
|
|
|
|
void set16(vector<const vector<int>>) {}
|
|
void test16() {
|
|
set16(vector<const vector<const int>>());
|
|
}
|
|
// CHECK-ELIDE-NOTREE: no matching function for call to 'set16'
|
|
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<const vector<const int>>' to 'vector<const vector<int>>' for 1st argument
|
|
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set16'
|
|
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<const vector<const int>>' to 'vector<const vector<int>>' for 1st argument
|
|
// CHECK-ELIDE-TREE: no matching function for call to 'set16'
|
|
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-ELIDE-TREE: vector<
|
|
// CHECK-ELIDE-TREE: const vector<
|
|
// CHECK-ELIDE-TREE: [const != (no qualifiers)] int>>
|
|
// CHECK-NOELIDE-TREE: no matching function for call to 'set16'
|
|
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-NOELIDE-TREE: vector<
|
|
// CHECK-NOELIDE-TREE: const vector<
|
|
// CHECK-NOELIDE-TREE: [const != (no qualifiers)] int>>
|
|
|
|
void set17(vector<vector<int>>) {}
|
|
void test17() {
|
|
set17(vector<const vector<int>>());
|
|
}
|
|
// CHECK-ELIDE-NOTREE: no matching function for call to 'set17'
|
|
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<const vector<...>>' to 'vector<vector<...>>' for 1st argument
|
|
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set17'
|
|
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<const vector<int>>' to 'vector<vector<int>>' for 1st argument
|
|
// CHECK-ELIDE-TREE: no matching function for call to 'set17'
|
|
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-ELIDE-TREE: vector<
|
|
// CHECK-ELIDE-TREE: [const != (no qualifiers)] vector<...>>
|
|
// CHECK-NOELIDE-TREE: no matching function for call to 'set17'
|
|
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-NOELIDE-TREE: vector<
|
|
// CHECK-NOELIDE-TREE: [const != (no qualifiers)] vector<
|
|
// CHECK-NOELIDE-TREE: int>>
|
|
|
|
void set18(vector<const vector<int>>) {}
|
|
void test18() {
|
|
set18(vector<vector<int>>());
|
|
}
|
|
// CHECK-ELIDE-NOTREE: no matching function for call to 'set18'
|
|
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<vector<...>>' to 'vector<const vector<...>>' for 1st argument
|
|
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set18'
|
|
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<vector<int>>' to 'vector<const vector<int>>' for 1st argument
|
|
// CHECK-ELIDE-TREE: no matching function for call to 'set18'
|
|
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-ELIDE-TREE: vector<
|
|
// CHECK-ELIDE-TREE: [(no qualifiers) != const] vector<...>>
|
|
// CHECK-NOELIDE-TREE: no matching function for call to 'set18'
|
|
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-NOELIDE-TREE: vector<
|
|
// CHECK-NOELIDE-TREE: [(no qualifiers) != const] vector<
|
|
// CHECK-NOELIDE-TREE: int>>
|
|
|
|
void set19(vector<volatile vector<int>>) {}
|
|
void test19() {
|
|
set19(vector<const vector<int>>());
|
|
}
|
|
// CHECK-ELIDE-NOTREE: no matching function for call to 'set19'
|
|
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<const vector<...>>' to 'vector<volatile vector<...>>' for 1st argument
|
|
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set19'
|
|
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<const vector<int>>' to 'vector<volatile vector<int>>' for 1st argument
|
|
// CHECK-ELIDE-TREE: no matching function for call to 'set19'
|
|
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-ELIDE-TREE: vector<
|
|
// CHECK-ELIDE-TREE: [const != volatile] vector<...>>
|
|
// CHECK-NOELIDE-TREE: no matching function for call to 'set19'
|
|
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-NOELIDE-TREE: vector<
|
|
// CHECK-NOELIDE-TREE: [const != volatile] vector<
|
|
// CHECK-NOELIDE-TREE: int>>
|
|
|
|
void set20(vector<const volatile vector<int>>) {}
|
|
void test20() {
|
|
set20(vector<const vector<int>>());
|
|
}
|
|
// CHECK-ELIDE-NOTREE: no matching function for call to 'set20'
|
|
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<const vector<...>>' to 'vector<const volatile vector<...>>' for 1st argument
|
|
// CHECK-NOELIDE-NOTREE: no matching function for call to 'set20'
|
|
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<const vector<int>>' to 'vector<const volatile vector<int>>' for 1st argument
|
|
// CHECK-ELIDE-TREE: no matching function for call to 'set20'
|
|
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-ELIDE-TREE: vector<
|
|
// CHECK-ELIDE-TREE: [const != const volatile] vector<...>>
|
|
// CHECK-NOELIDE-TREE: no matching function for call to 'set20'
|
|
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-NOELIDE-TREE: vector<
|
|
// CHECK-NOELIDE-TREE: [const != const volatile] vector<
|
|
// CHECK-NOELIDE-TREE: int>>
|
|
|
|
|
|
// Checks that volatile does not show up in diagnostics.
|
|
template<typename T> struct S21 {};
|
|
template<typename T> using U21 = volatile S21<T>;
|
|
int f21(vector<const U21<int>>);
|
|
int k21 = f21(vector<U21<int>>());
|
|
// CHECK-ELIDE-NOTREE: no matching function for call to 'f21'
|
|
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<U21<...>>' to 'vector<const U21<...>>' for 1st argument
|
|
// CHECK-NOELIDE-NOTREE: no matching function for call to 'f21'
|
|
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<U21<int>>' to 'vector<const U21<int>>' for 1st argument
|
|
// CHECK-ELIDE-TREE: no matching function for call to 'f21'
|
|
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-ELIDE-TREE: vector<
|
|
// CHECK-ELIDE-TREE: [(no qualifiers) != const] U21<...>>
|
|
// CHECK-NOELIDE-TREE: no matching function for call to 'f21'
|
|
// CHECK-NOELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-NOELIDE-TREE: vector<
|
|
// CHECK-NOELIDE-TREE: [(no qualifiers) != const] U21<
|
|
// CHECK-NOELIDE-TREE: int>>
|
|
|
|
// Checks that volatile does not show up in diagnostics.
|
|
template<typename T> struct S22 {};
|
|
template<typename T> using U22 = volatile S22<T>;
|
|
int f22(vector<volatile const U22<int>>);
|
|
int k22 = f22(vector<volatile U22<int>>());
|
|
// CHECK-ELIDE-NOTREE: no matching function for call to 'f22'
|
|
// CHECK-ELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<U22<...>>' to 'vector<const U22<...>>' for 1st argument
|
|
// CHECK-NOELIDE-NOTREE: no matching function for call to 'f22'
|
|
// CHECK-NOELIDE-NOTREE: candidate function not viable: no known conversion from 'vector<U22<int>>' to 'vector<const U22<int>>' for 1st argument
|
|
// CHECK-ELIDE-TREE: no matching function for call to 'f22'
|
|
// CHECK-ELIDE-TREE: candidate function not viable: no known conversion from argument type to parameter type for 1st argument
|
|
// CHECK-ELIDE-TREE: vector<
|
|
// CHECK-ELIDE-TREE: [(no qualifiers) != const] U22<...>>
|
|
// CHECK-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<>]>
|
|
|
|
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 '='
|
|
// 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
|
|
// 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 '='
|
|
// 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
|
|
// 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 '='
|
|
// 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
|
|
// 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 '='
|
|
// 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
|
|
// 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
|
|
// CHECK-ELIDE-TREE: [(no qualifiers) != const] Foo1<
|
|
// 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
|
|
// CHECK-ELIDE-TREE: [(no qualifiers) != const] Foo1<
|
|
// 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
|
|
// CHECK-NOELIDE-TREE: [(no qualifiers) != const] Foo1<
|
|
// 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
|
|
// CHECK-NOELIDE-TREE: [(no qualifiers) != const] Foo1<
|
|
// 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 '='
|
|
// 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
|
|
// 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 '='
|
|
// 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
|
|
// 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 '='
|
|
// 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
|
|
// 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 '='
|
|
// 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
|
|
// 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
|
|
// CHECK-ELIDE-TREE: [(no qualifiers) != const] Foo2<
|
|
// 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
|
|
// CHECK-ELIDE-TREE: [(no qualifiers) != const] Foo2<
|
|
// 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
|
|
// CHECK-NOELIDE-TREE: [(no qualifiers) != const] Foo2<
|
|
// 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
|
|
// CHECK-NOELIDE-TREE: [(no qualifiers) != const] Foo2<
|
|
// 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 '='
|
|
// 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
|
|
// 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 '='
|
|
// 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
|
|
// 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 '='
|
|
// 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
|
|
// 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 '='
|
|
// 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
|
|
// 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
|
|
// CHECK-ELIDE-TREE: [(no qualifiers) != const] Foo3<
|
|
// 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
|
|
// CHECK-ELIDE-TREE: [(no qualifiers) != const] Foo3<
|
|
// 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
|
|
// CHECK-NOELIDE-TREE: [(no qualifiers) != const] Foo3<
|
|
// 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
|
|
// CHECK-NOELIDE-TREE: [(no qualifiers) != const] Foo3<
|
|
// 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)]>
|
|
}
|
|
|
|
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, [...]>'
|
|
// CHECK-ELIDE-NOTREE: error: no viable conversion from 'X<[...], 2>' to 'X<[...], 3>'
|
|
}
|
|
|
|
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<>'
|
|
}
|
|
|
|
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();
|
|
};
|
|
}
|
|
|
|
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>)
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
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>'
|
|
|
|
}
|
|
}
|
|
|
|
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 '='
|
|
// CHECK-ELIDE-NOTREE: no known conversion from 'A<[...], (default) Trait<T>::V aka 40>' to 'A<[...], 10>'
|
|
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 '='
|
|
// CHECK-ELIDE-NOTREE: no known conversion from 'B<char, [...]>' to 'B<int, [...]>'
|
|
b3 = b1;
|
|
// CHECK-ELIDE-NOTREE: no viable overloaded '='
|
|
// CHECK-ELIDE-NOTREE: no known conversion from 'B<[...], (default) int>' to 'B<[...], char>'
|
|
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>'
|
|
}
|
|
}
|
|
|
|
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>'
|
|
|
|
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>'
|
|
|
|
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>'
|
|
}
|
|
}
|
|
|
|
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
|
|
|
|
}
|
|
}
|
|
|
|
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;
|
|
// CHECK-ELIDE-NOTREE: no viable conversion from 'M<C<DependentInt::N, INT<1>>>' to 'M<C<int, INT<0>>>'
|
|
}
|
|
}
|
|
|
|
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);
|
|
// CHECK-ELIDE-NOTREE: no known conversion from 'vector<PR17510::Atom *, [...]>' to 'const vector<const PR17510::Atom *, [...]>'
|
|
}
|
|
}
|
|
|
|
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>')
|
|
}
|
|
}
|
|
|
|
namespace AddressOf {
|
|
template <int*>
|
|
struct S {};
|
|
|
|
template <class T>
|
|
struct Wrapper {};
|
|
|
|
template <class T>
|
|
Wrapper<T> MakeWrapper();
|
|
int global, global2;
|
|
constexpr int * ptr = nullptr;
|
|
Wrapper<S<ptr>> W = MakeWrapper<S<&global>>();
|
|
// Don't print an extra '&' for 'ptr'
|
|
// CHECK-ELIDE-NOTREE: no viable conversion from 'Wrapper<S<&global>>' to 'Wrapper<S<ptr aka nullptr>>'
|
|
|
|
// Handle parens correctly
|
|
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>>'
|
|
}
|
|
|
|
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>();
|
|
// CHECK-ELIDE-NOTREE: no viable conversion from 'S<[...], &global>' to 'S<[...], ptr aka nullptr>
|
|
|
|
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>>();
|
|
// CHECK-ELIDE-NOTREE: no viable conversion from 'Wrapper<S<[...], &global>>' to 'Wrapper<S<[...], ptr aka nullptr>>'
|
|
|
|
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>>();
|
|
// CHECK-ELIDE-NOTREE: no viable conversion from 'Wrapper<S<[...], nullptr>>' to 'Wrapper<S<[...], &global>>'
|
|
Wrapper<S<&global, ptr>> W14 = MakeWrapper<S<&global, &global>>();
|
|
// CHECK-ELIDE-NOTREE: no viable conversion from 'Wrapper<S<[...], &global>>' to 'Wrapper<S<[...], ptr aka nullptr>>'
|
|
}
|
|
|
|
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, [...]>'
|
|
}
|
|
|
|
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>'
|
|
}
|
|
|
|
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>')
|
|
}
|
|
|
|
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;
|
|
}
|
|
// CHECK-ELIDE-NOTREE: binding reference of type 'condition<...>' to value of type 'const condition<...>' drops 'const' qualifier
|
|
}
|
|
|
|
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'
|
|
// CHECK-ELIDE-NOTREE: candidate function template not viable: no known conversion from 'BoolT<false>' to 'BoolT<true>' for 1st argument
|
|
}
|
|
|
|
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>'
|
|
}
|
|
|
|
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]>
|
|
}
|
|
|
|
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(); }
|
|
// CHECK-ELIDE-NOTREE: error: non-const lvalue reference to type 'A<...>' cannot bind to a temporary of type 'A<...>'
|
|
// 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'
|
|
// CHECK-ELIDE-NOTREE: note: candidate function template not viable: no known conversion from 'integral_constant<[...], true>' to 'integral_constant<[...], false>' for 2nd argument
|
|
}
|
|
|
|
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>'
|
|
// 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<...>>'
|
|
}
|
|
|
|
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'
|
|
// 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
|
|
}
|
|
|
|
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>);
|
|
|
|
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
|
|
}
|
|
}
|
|
|
|
// 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.
|
|
|
|
namespace pr30831 {
|
|
template <typename T> struct A { static A<T> const a; };
|
|
template <typename T> A<T> A<T>::a = A<T>();
|
|
}
|